slack-smart-bot 1.15.1 → 1.15.25

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

@@ -17,10 +17,10 @@ class SlackSmartBot
             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 = ''
+              session_name = ""
             end
 
-            if session_name != "" and @active_chat_gpt_sessions[team_id_user].key?(Thread.current[:thread_ts])
+            if @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)
@@ -32,7 +32,7 @@ class SlackSmartBot
               @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."
+              respond "You can add collaborators for the chatGPT session only when started on a thread."
             end
           end
         end

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

@@ -3,7 +3,7 @@ class SlackSmartBot
     module General
       module AI
         module OpenAI
-          def open_ai_chat_copy_session(team_orig, user_orig, session_name, new_session_name)
+          def open_ai_chat_copy_session(team_orig, user_orig, session_name, new_session_name, temporary_session: false)
             if user_orig == ""
               save_stats(__method__)
             else
@@ -13,28 +13,71 @@ class SlackSmartBot
             user = Thread.current[:user].dup
             team_id = user.team_id
             if user_orig == ""
-              user_orig = user.name 
+              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 temporary_session
+              if @open_ai.key?(team_id_user) and @open_ai[team_id_user][:chat_gpt][:sessions].key?("") and
+                 @open_ai[team_id_user][:chat_gpt][:sessions][""].key?(:thread_ts)
+                @open_ai[team_id_user][: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 = ":information_source: 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].delete(thread_ts)
+                    @listening[:threads].delete(thread_ts)
+                    @open_ai[team_id_user][:chat_gpt][:sessions][""][:collaborators].each do |team_id_user_collaborator|
+                      if @listening.key?(team_id_user_collaborator)
+                        @listening[team_id_user_collaborator].delete(thread_ts)
+                      end
+                      if @chat_gpt_collaborating.key?(team_id_user_collaborator) && @chat_gpt_collaborating[team_id_user_collaborator].key?(thread_ts)
+                        @chat_gpt_collaborating[team_id_user_collaborator].delete(thread_ts)
+                      end
+                    end
+                  end
+                end
+              end
+            end
+
+            if user_orig != user.name and dest[0] == "D" and @open_ai.key?(orig_team_id_user) and
+               @open_ai[orig_team_id_user][:chat_gpt][:sessions].key?(session_name) and
+               @open_ai[orig_team_id_user][:chat_gpt][:sessions][session_name][:shared].size > 0
+              members_shared = []
+              @open_ai[orig_team_id_user][:chat_gpt][:sessions][session_name][:shared].each do |shared|
+                members_shared += get_channel_members(shared)
+              end
+              members_shared.uniq!
+            else
+              members_shared = []
+            end
             if !@open_ai.key?(orig_team_id_user)
               respond "*ChatGPT*: The user *#{user_orig}* doesn't exist."
+              return false
             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
+              return false
+            elsif user_orig != user.name and dest[0] == "D" 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].size > 0 and
+                  !members_shared.include?(user.id)
+              respond "*ChatGPT*: The session *#{session_name}* doesn't exist or it is not shared."
+            elsif user_orig != user.name and dest[0] != "D" 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."
+              return false
             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[team_id_user][:chat_gpt][:sessions] ||= {}
+              session_orig = @open_ai[orig_team_id_user][:chat_gpt][:sessions][session_name].deep_copy
               open_ai_new_session = {
                 team_creator: team_id,
                 user_creator: user.name,
@@ -48,13 +91,40 @@ class SlackSmartBot
                 copy_of_team: team_orig,
                 copy_of_user: user_orig,
                 users_copying: [],
+                temp_copies: 0,
+                own_temp_copies: 0,
                 public: false,
                 description: session_orig[:description],
-                tag: session_orig[:tag]
+                tag: session_orig[:tag],
+                live_content: session_orig[:live_content],
+                static_content: session_orig[:static_content],
+                authorizations: session_orig[:authorizations],
               }
-              new_session_name = session_name if new_session_name == ""
+              if !temporary_session and (team_orig != team_id or user_orig != user.name)
+                open_ai_new_session[:authorizations] = {}
+                message_auth = "\n:lock: Authorizations were removed on copy."
+              elsif !temporary_session and session_orig[:copy_of_session] != "" and
+                    (session_orig[:copy_of_team] != team_id or session_orig[:copy_of_user] != user.name)
+                open_ai_new_session[:authorizations] = {}
+                message_auth = "\n:lock: Authorizations were removed on copy."
+              else
+                message_auth = ""
+              end
+              message_history = ""
+              if team_orig != team_id or user_orig != user.name
+                if session_orig.key?(:static_content)
+                  session_orig[:static_content].each do |cont|
+                    if cont.match?(/\AHistory of <#(\w+)>\Z/im) #jal66
+                      respond "*ChatGPT*: The session *#{session_name}* contains the history of a Slack Channel. Sorry, but I can't copy it."
+                      return false
+                    end
+                  end
+                end
+              end
+
+              new_session_name = session_name if new_session_name == "" and !temporary_session
               session_names = @open_ai[team_id_user][:chat_gpt][:sessions].keys
-              if session_names.include?(new_session_name)
+              if session_names.include?(new_session_name) and !temporary_session
                 number = session_names.join("\n").scan(/^#{new_session_name}(\d+)$/).max
                 if number.nil?
                   number = "1"
@@ -63,23 +133,70 @@ class SlackSmartBot
                 end
                 new_session_name = "#{new_session_name}#{number}"
               end
+
               @open_ai[team_id_user][:chat_gpt][:sessions][new_session_name] = open_ai_new_session
+              @ai_gpt[team_id_user][""] = [] if temporary_session and @ai_gpt.key?(team_id_user)
 
               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
+                if temporary_session
+                  @open_ai[orig_team_id_user][:chat_gpt][:sessions][session_name][:temp_copies] ||= 0
+                  @open_ai[orig_team_id_user][:chat_gpt][:sessions][session_name][:temp_copies] += 1
+                else
+                  @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
+                end
                 update_openai_sessions("", team_id: team_orig, user_name: user_orig)
+              else
+                if temporary_session
+                  @open_ai[orig_team_id_user][:chat_gpt][:sessions][session_name][:own_temp_copies] ||= 0
+                  @open_ai[orig_team_id_user][:chat_gpt][:sessions][session_name][:own_temp_copies] += 1
+                  update_openai_sessions("", team_id: team_orig, user_name: user_orig)
+                end
               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 @ai_gpt.key?(orig_team_id_user) and @ai_gpt[orig_team_id_user].key?(session_name)
+                @ai_gpt[team_id_user][new_session_name] = @ai_gpt[orig_team_id_user][session_name].deep_copy
+              else
+                @ai_gpt[team_id_user][new_session_name] = []
+              end
+              update_openai_sessions(new_session_name, team_id: team_id, user_name: user.name) unless temporary_session
+
               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."
+                if temporary_session
+                  res_message = "*ChatGPT*: Session *#{session_name}* (#{user_orig}) copied to be used as a temporary session.#{message_auth}#{message_history}"
+                else
+                  res_message = "*ChatGPT*: Session *#{session_name}* (#{user_orig}) copied to #{new_session_name}.#{message_auth}#{message_history}\nNow you can call `^chatGPT #{new_session_name}` to use it."
+                end
               else
-                respond "*ChatGPT*: Session #{session_name} copied to #{new_session_name}.\nNow you can call `^chatGPT #{new_session_name}` to use it."
+                if temporary_session
+                  res_message = "*ChatGPT*: Session *#{session_name}* copied to be used as a temporary session.#{message_auth}#{message_history}"
+                else
+                  res_message = "*ChatGPT*: Session *#{session_name}* copied to #{new_session_name}.#{message_auth}#{message_history}\nNow you can call `^chatGPT #{new_session_name}` to use it."
+                end
+              end
+              if !@open_ai[team_id_user][:chat_gpt][:sessions][new_session_name][:live_content].nil? and
+                 @open_ai[team_id_user][:chat_gpt][:sessions][new_session_name][:live_content].size > 0
+                live_content = "\n:globe_with_meridians: *Live content*:\n\t\t - `#{@open_ai[team_id_user][:chat_gpt][:sessions][new_session_name][:live_content].join("`\n\t\t - `")}`"
+                res_message += live_content
+              end
+              if !@open_ai[team_id_user][:chat_gpt][:sessions][new_session_name][:static_content].nil? and
+                 @open_ai[team_id_user][:chat_gpt][:sessions][new_session_name][:static_content].size > 0
+                static_content = "\n:pushpin: *Static content*:\n\t\t - `#{@open_ai[team_id_user][:chat_gpt][:sessions][new_session_name][:static_content].join("`\n\t\t - `")}`"
+                res_message += static_content
+              end
+
+              if !@open_ai[team_id_user][:chat_gpt][:sessions][new_session_name][:authorizations].nil? and
+                 @open_ai[team_id_user][:chat_gpt][:sessions][new_session_name][:authorizations].size > 0
+                auth = "\n:lock: *Authorizations*:\n"
+                @open_ai[team_id_user][:chat_gpt][:sessions][new_session_name][:authorizations].each do |host, header|
+                  auth += "\t\t - `#{host}`: `#{header.keys.join("`, `")}`\n"
+                end
+                res_message += auth
               end
+              respond res_message
+              return true
             end
           end
         end

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

@@ -31,7 +31,7 @@ class SlackSmartBot
               end
 
               @open_ai[team_id_user][:chat_gpt][:sessions].delete(session_name)
-
+              @ai_gpt[team_id_user].delete(session_name) if @ai_gpt.key?(team_id_user)
               update_openai_sessions(session_name)
               respond "*ChatGPT*: Session *#{session_name}* deleted."
             else

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

@@ -6,29 +6,67 @@ class SlackSmartBot
           def open_ai_chat_get_prompts(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] ||= {}
 
             get_openai_sessions(session_name)
-            
+
             if @open_ai[team_id_user][:chat_gpt][:sessions].key?(session_name)
-              prompts = @ai_gpt[team_id_user][session_name].join("\n")
-              prompts.gsub!(/^Me>\s*/, "\nMe> ")
-              prompts.gsub!(/^chatGPT>\s*/, "\nchatGPT> ")
-              if prompts.length > 3000
+              prompts = ""
+              prompts_array = @ai_gpt[team_id_user][session_name]
+              prompts_array.each do |prompt|
+                if prompt[:role] == "user" and prompt[:content].size > 0 and prompt[:content][0][:type] == "text"
+                  if prompt[:content][0].key?(:clean_text)
+                    #if not a static content
+                    if @open_ai[team_id_user][:chat_gpt][:sessions][session_name][:static_content].nil? or
+                       !@open_ai[team_id_user][:chat_gpt][:sessions][session_name][:static_content].include?(prompt[:content][0][:clean_text])
+                      prompts += "\n\n:runner: *User>* #{prompt[:content][0][:clean_text]}\n"
+                    end
+                  else
+                    prompts += "\n\n:runner: *User>* #{prompt[:content][0][:text]}\n"
+                  end
+                elsif prompt[:role] == "user" and prompt[:content].size > 0 and prompt[:content][0][:type] != "text"
+                  prompts += "\n\n:runner: *User>* Attached file type #{prompt[:content][0][:type]}\n"
+                elsif prompt[:role] == "assistant" and prompt[:content].size > 0 and prompt[:content][0][:type] == "text"
+                  prompts += "\n:speech_balloon: *chatGPT>* #{prompt[:content][0][:text]}\n"
+                elsif prompt[:role] == "system" and prompt[:content].size > 0 and prompt[:content][0][:type] == "text"
+                  prompts += "\n:robot_face: *Context:* #{prompt[:content][0][:text]}\n"
+                else
+                  prompts += "Attention! This message is not in the expected format.\n"
+                end
+              end
+              if !@open_ai[team_id_user][:chat_gpt][:sessions][session_name][:live_content].nil? and
+                 @open_ai[team_id_user][:chat_gpt][:sessions][session_name][:live_content].size > 0
+                prompts += "\n:globe_with_meridians: *Live content:*\n"
+                @open_ai[team_id_user][:chat_gpt][:sessions][session_name][:live_content].each do |live_content|
+                  prompts += "\t\t - #{live_content}\n"
+                end
+              end
+              if !@open_ai[team_id_user][:chat_gpt][:sessions][session_name][:static_content].nil? and
+                 @open_ai[team_id_user][:chat_gpt][:sessions][session_name][:static_content].size > 0
+                prompts += "\n:pushpin: *Static content:*\n"
+                @open_ai[team_id_user][:chat_gpt][:sessions][session_name][:static_content].each do |static_content|
+                  prompts += "\t\t - #{static_content}\n"
+                end
+              end
+              #authorizations
+              if !@open_ai[team_id_user][:chat_gpt][:sessions][session_name][:authorizations].nil? and
+                 @open_ai[team_id_user][:chat_gpt][:sessions][session_name][:authorizations].size > 0
+                prompts += "\n:lock: *Authorizations:*\n"
+                @open_ai[team_id_user][:chat_gpt][:sessions][session_name][:authorizations].each do |host, header|
+                  prompts += "\t\t - `#{host}`: `#{header.keys.join("`, `")}`\n"
+                end
+              end
+
+              if prompts.length > 5000
                 respond "*ChatGPT*: Session *#{session_name}*."
                 send_file(Thread.current[:dest], "ChatGPT prompts for #{session_name}", "prompts.txt", "prompts", "text/plain", "text", content: prompts)
               elsif prompts.empty?
                 respond "*ChatGPT*: Session *#{session_name}* has no prompts."
               else
                 respond "*ChatGPT*: Session *#{session_name}*."
-                if prompts.include?("`")
-                  respond prompts
-                else
-                  respond "```#{prompts}```"
-                end
+                respond transform_to_slack_markdown(prompts)
               end
             else
               respond "*ChatGPT*: You don't have a session with that name.\nCall `chatGPT list sessions` to see your saved sessions."

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

@@ -3,7 +3,7 @@ class SlackSmartBot
     module General
       module AI
         module OpenAI
-          def open_ai_chat_list_sessions(type, tag: '') #type can be :own or :public or :shared
+          def open_ai_chat_list_sessions(type, tag: "") #type can be :own or :public or :shared
             save_stats(__method__)
 
             user = Thread.current[:user].dup
@@ -11,6 +11,7 @@ class SlackSmartBot
             team_id_user = Thread.current[:team_id_user]
 
             channel = Thread.current[:dest]
+            on_dm = channel[0] == "D"
 
             get_openai_sessions()
             check_users = []
@@ -19,60 +20,124 @@ class SlackSmartBot
             else
               check_users = @open_ai.keys
             end
+            members = {}
 
-            list_sessions = []
+            list_sessions = {}
             check_users.each do |team_user_name|
               if @open_ai.key?(team_user_name) and @open_ai[team_user_name].key?(:chat_gpt) and
-                @open_ai[team_user_name][:chat_gpt].key?(:sessions) and
-                @open_ai[team_user_name][:chat_gpt][:sessions].size > 0
-
+                 @open_ai[team_user_name][:chat_gpt].key?(:sessions) and
+                 @open_ai[team_user_name][:chat_gpt][:sessions].size > 0
                 sessions = @open_ai[team_user_name][:chat_gpt][:sessions].keys.sort
                 sessions.delete("")
+
                 sessions.each do |session_name|
                   session = @open_ai[team_user_name][:chat_gpt][:sessions][session_name]
+                  if type == :shared and on_dm and session.key?(:shared)
+                    session[:shared].each do |channel_shared|
+                      members[channel_shared] ||= get_channel_members(channel_shared)
+                    end
+                  end
                   if (type == :own and session[:user_creator] == user.name) or
-                    (type == :public and session.key?(:public) and session[:public]) or
-                    (type == :shared and session.key?(:shared) and session[:shared].include?(channel))
-
-                    if tag == '' or (session.key?(:tag) and tag == session[:tag].to_s)
-                      if !session.key?(:team_creator) or session[:team_creator] == ''
-                        session[:team_creator] = config.team_id
+                     (type == :public and session.key?(:public) and session[:public]) or
+                     (type == :shared and session.key?(:shared) and session[:shared].include?(channel)) or
+                     (type == :shared and session.key?(:shared) and on_dm and session[:shared].size > 0)
+                    if tag == "" or (session.key?(:tag) and tag == session[:tag].to_s)
+                      if type == :shared and on_dm
+                        channels_check = []
+                        session.shared.each do |channel_shared|
+                          channels_check << channel_shared if members.key?(channel_shared) and !members[channel_shared].nil? and members[channel_shared].include?(user.id)
+                        end
+                      else
+                        channels_check = [channel]
+                      end
+                      channels_check.each do |channel_check|
+                        if !session.key?(:team_creator) or session[:team_creator] == ""
+                          session[:team_creator] = config.team_id
+                        end
+                        #get the last context from prompts
+                        team_user_creator = session[:team_creator] + "_" + session[:user_creator]
+                        if !@ai_gpt.key?(team_user_creator) or !@ai_gpt[team_user_creator].key?(session_name)
+                          get_openai_sessions(session_name, team_id: session[:team_creator], user_name: session[:user_creator])
+                        end
+                        if @ai_gpt.key?(team_user_creator) and @ai_gpt[team_user_creator].key?(session_name)
+                          prompts_array = @ai_gpt[team_user_creator][session_name]
+                        else
+                          prompts_array = []
+                        end
+                        context = ""
+                        if prompts_array.size > 0
+                          prompts_array.reverse.each do |prompt|
+                            if prompt[:role] == "system" and prompt[:content].size > 0 and prompt[:content][0][:type] == "text"
+                              context = prompt[:content][0][:text]
+                              break
+                            end
+                          end
+                        end
+                        list_session = []
+                        list_session << "*`#{session_name}`*: "
+                        list_session[-1] << "_#{session[:description]}_ " if session.key?(:description) and session[:description].to_s.strip != ""
+                        list_session[-1] << "*(public)* " if session.key?(:public) and session[:public] and type != :public
+                        list_session[-1] << "(shared on <##{session.shared.join(">, <#")}>) " if session.key?(:shared) and session[:shared].size > 0 and type != :shared
+                        list_session[-1] << "\n\t:spiral_note_pad: *#{session.num_prompts}* prompts. "
+                        list_session[-1] << " tag: >*#{session.tag}*. " if session.key?(:tag) and session[:tag].to_s != "" and tag == ""
+                        list_session[-1] << "shared by: *#{session.user_creator}*. " if type != :own
+                        list_session[-1] << "original creator: *#{session.copy_of_user}*. " if session.key?(:copy_of_user) and session[:copy_of_user] != "" and session[:copy_of_user] != session[:user_creator]
+                        list_session[-1] << "model: #{session.model}. " if session.key?(:model) and session[:model] != ""
+                        if on_dm and config.masters.include?(user.name)
+                          list_session[-1] << "copies: #{session.users_copying.size}. " if session.key?(:users_copying) and session[:users_copying].size > 0
+                          list_session[-1] << "users: #{session.users_copying.uniq.size}. " if session.key?(:users_copying) and session[:users_copying].size > 0
+                          list_session[-1] << "temp copies: #{session.temp_copies}. " if session.key?(:temp_copies) and session[:temp_copies] > 0
+                          list_session[-1] << "own temp copies: #{session.own_temp_copies}. " if session.key?(:own_temp_copies) and session[:own_temp_copies] > 0
+                        else
+                          num_copies = session.users_copying.size + session.temp_copies.to_i + session.own_temp_copies.to_i
+                          list_session[-1] << "copies: #{num_copies}. " if num_copies > 0
+                        end
+                        list_session[-1] << "collaborators: *#{session.collaborators.join(", ").gsub("#{team_id}_", "")}*. " unless !session.key?(:collaborators) or session.collaborators.empty?
+                        list_session[-1] << "last prompt: #{session.last_activity.gsub("-", "/")[0..15]}. " if type == :own
+                        list_session[-1] << "\n\t:robot_face: context: #{context}" if context != ""
+                        list_session[-1] << "\n\t:pushpin: static content:\n\t\t#{session.static_content.join("\n\t\t")}" if !session[:static_content].nil? and session[:static_content].size > 0
+                        list_session[-1] << "\n\t:globe_with_meridians: live content:\n\t\t#{session.live_content.join("\n\t\t")}" if !session[:live_content].nil? and session[:live_content].size > 0
+                        path_to_docs_folder_file = "#{config.path}/openai/#{session.team_creator}/#{session.user_creator}/#{session_name}/chatgpt_prompts.json"
+                        if File.exist?(path_to_docs_folder_file)
+                          num_docs = JSON.parse(File.read(path_to_docs_folder_file)).size
+                          list_session[-1] << "\n\t:notebook_with_decorative_cover: #{num_docs} documents can be used in this session." if num_docs > 0
+                        end
+                        if session.key?(:authorizations) and session[:authorizations].size > 0
+                          list_session[-1] << "\n\t:lock: authorizations:\n"
+                          session[:authorizations].each do |key, value|
+                            list_session[-1] << "\t\t#{key}\n"
+                          end
+                        end
+                        list_sessions[channel_check] ||= []
+                        list_sessions[channel_check] += list_session
                       end
-                      list_sessions << "*`#{session_name}`*: "
-                      list_sessions[-1]<<"_#{session[:description]}_ " if session.key?(:description) and session[:description].to_s.strip != ''
-                      list_sessions[-1]<<"*(public)* " if session.key?(:public) and session[:public] and type != :public
-                      list_sessions[-1]<<"(shared on <##{session.shared.join(">, <#")}>) " if session.key?(:shared) and session[:shared].size > 0 and type != :shared
-                      list_sessions[-1]<<"\n     *#{session.num_prompts}* prompts. "
-                      list_sessions[-1]<<" tag: >*#{session.tag}*. " if session.key?(:tag) and session[:tag].to_s != '' and tag == ''
-                      list_sessions[-1]<<"shared by: *#{session.user_creator}*. " if type != :own
-                      list_sessions[-1]<<"original creator: *#{session.copy_of_user}*. " if session.key?(:copy_of_user) and session[:copy_of_user] != '' and session[:copy_of_user] != session[:user_creator]
-                      list_sessions[-1]<<"model: #{session.model}. " if session.key?(:model) and session[:model] != ''
-                      list_sessions[-1]<<"copies: #{session.users_copying.size}. " if session.key?(:users_copying) and session[:users_copying].size > 0
-                      list_sessions[-1]<<"users: #{session.users_copying.uniq.size}. " if session.key?(:users_copying) and session[:users_copying].size > 0
-                      list_sessions[-1]<<"collaborators: *#{session.collaborators.join(", ").gsub("#{team_id}_","")}*. " unless !session.key?(:collaborators) or session.collaborators.empty?
-                      list_sessions[-1]<<"last prompt: #{session.last_activity.gsub("-", "/")[0..15]}. " if type == :own
                     end
                   end
                 end
               end
             end
             if list_sessions.size > 0
-              list_sessions[-1] << "\n\n:information_source: To start using a session: `chatgpt use USER_SHARED SESSION_NAME`" if type != :own
-              if type == :own
-                respond "*ChatGPT*: Your#{" >*#{tag}*" if tag!=''} sessions:\n\n#{list_sessions.join("\n\n")}"
-              elsif type == :public
-                respond "*ChatGPT*: Public#{" >*#{tag}*" if tag!=''} sessions:\n\n#{list_sessions.join("\n\n")}"
-              elsif type == :shared
-                respond "*ChatGPT*: Shared#{" >*#{tag}*" if tag!=''} sessions on <##{channel}>:\n\n#{list_sessions.join("\n\n")}"
+              list_sessions.each do |channel, list|
+                if type == :own
+                  respond "*ChatGPT*: Your#{" >*#{tag}*" if tag != ""} sessions:\n\n#{list.join("\n\n")}", unfurl_links: false
+                elsif type == :public
+                  respond "*ChatGPT*: Public#{" >*#{tag}*" if tag != ""} sessions on #{config.team_name}:\n\n#{list.join("\n\n")}", unfurl_links: false
+                elsif type == :shared
+                  if channel[0] == "D" and @rules_imported[team_id_user].key?(user.name) and @rules_imported[team_id_user][user.name] != ""
+                    respond "*ChatGPT*: Shared#{" >*#{tag}*" if tag != ""} sessions on <##{@rules_imported[team_id_user][user.name]}>:\n\n#{list.join("\n\n")}", unfurl_links: false
+                  else
+                    respond "*ChatGPT*: Shared#{" >*#{tag}*" if tag != ""} sessions on <##{channel}>:\n\n#{list.join("\n\n")}", unfurl_links: false
+                  end
+                end
               end
+              respond "\n\n:information_source: To start using a session: `chatgpt use USER_SHARED SESSION_NAME` or `?? use SESSION_NAME PROMPT`" if type != :own
             else
               if type == :own
-                respond "*ChatGPT*: You don't have any#{" >*#{tag}*" if tag!=''} sessions."
+                respond "*ChatGPT*: You don't have any#{" >*#{tag}*" if tag != ""} sessions."
               else
-                respond "*ChatGPT*: There are no#{" >*#{tag}*" if tag!=''} #{type} sessions."
+                respond "*ChatGPT*: There are no#{" >*#{tag}*" if tag != ""} #{type} sessions."
               end
             end
-
           end
         end
       end

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

@@ -22,9 +22,19 @@ class SlackSmartBot
                 end
               elsif type == :stop
                 if channel_id == ""
-                  @open_ai[team_id_user][:chat_gpt][:sessions][session_name].public = false
+                  if @open_ai[team_id_user][:chat_gpt][:sessions][session_name].public
+                    @open_ai[team_id_user][:chat_gpt][:sessions][session_name].public = false
+                  else
+                    respond "*ChatGPT*: Session *#{session_name}* is not public."
+                    return
+                  end
                 else
-                  @open_ai[team_id_user][:chat_gpt][:sessions][session_name].shared.delete(channel_id)
+                  if @open_ai[team_id_user][:chat_gpt][:sessions][session_name].shared.include?(channel_id)
+                    @open_ai[team_id_user][:chat_gpt][:sessions][session_name].shared.delete(channel_id)
+                  else
+                    respond "*ChatGPT*: Session *#{session_name}* is not shared on <##{channel_id}>."
+                    return
+                  end
                 end
               end
               update_openai_sessions()

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

@@ -5,42 +5,53 @@ class SlackSmartBot
         module OpenAI
           def open_ai_chat_use_model(model, dont_save_stats: false)
             save_stats(__method__) unless dont_save_stats
-            open_ai_models('', just_models: true) if @open_ai_models.empty?
-            model_selected = @open_ai_models.select{|m| m==model}
-            model_selected = @open_ai_models.select{|m| m.include?(model)} if model_selected.empty?
+            open_ai_models("", just_models: true) if @open_ai_models.empty?
+            model_selected = @open_ai_models.select { |m| m == model }
+            model_selected = @open_ai_models.select { |m| m.include?(model) } if model_selected.empty?
             if model_selected.size == 1
               model = model_selected[0]
               user = Thread.current[:user].dup
               team_id_user = Thread.current[:team_id_user]
 
               user_name = user.name
-              if @chat_gpt_collaborating.key?(team_id_user) and @chat_gpt_collaborating[team_id_user].key?(Thread.current[:thread_ts])
-                user_creator = @chat_gpt_collaborating[team_id_user][Thread.current[:thread_ts]][:user_creator]
-                team_creator = @chat_gpt_collaborating[team_id_user][Thread.current[:thread_ts]][:team_creator]
-                team_id_user_creator = team_creator + "_" + user_creator
-                session_name = @chat_gpt_collaborating[team_id_user][Thread.current[:thread_ts]][:session_name]
-              else
-                user_creator = user.name
-                team_creator = user.team_id
-                team_id_user_creator = team_creator + "_" + user_creator
 
-                @active_chat_gpt_sessions[team_id_user_creator] ||= {}
-                if @active_chat_gpt_sessions[team_id_user_creator].key?(Thread.current[:thread_ts])
-                  session_name = @active_chat_gpt_sessions[team_id_user_creator][Thread.current[:thread_ts]]
-                elsif @active_chat_gpt_sessions[team_id_user_creator].key?(Thread.current[:dest])
-                  session_name = @active_chat_gpt_sessions[team_id_user_creator][Thread.current[:dest]]
-                else
-                  session_name = ''
+              restricted = false
+              if File.exist?("#{config.path}/openai/restricted_models.yaml")
+                restricted_models = YAML.load_file("#{config.path}/openai/restricted_models.yaml")
+                if restricted_models.key?(model) and !restricted_models[model].include?(team_id_user) and !restricted_models[model].include?(user_name)
+                  respond "You don't have access to this model. You can request access to an admin user."
+                  restricted = true
                 end
               end
-              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)
-                @open_ai[team_id_user_creator][:chat_gpt][:sessions][session_name][:model] = model
-                respond "Model for this session is now #{model}" unless dont_save_stats
-                update_openai_sessions(session_name, team_id: team_creator, user_name: user_creator) unless session_name == ''
+              unless restricted
+                if @chat_gpt_collaborating.key?(team_id_user) and @chat_gpt_collaborating[team_id_user].key?(Thread.current[:thread_ts])
+                  user_creator = @chat_gpt_collaborating[team_id_user][Thread.current[:thread_ts]][:user_creator]
+                  team_creator = @chat_gpt_collaborating[team_id_user][Thread.current[:thread_ts]][:team_creator]
+                  team_id_user_creator = team_creator + "_" + user_creator
+                  session_name = @chat_gpt_collaborating[team_id_user][Thread.current[:thread_ts]][:session_name]
+                else
+                  user_creator = user.name
+                  team_creator = user.team_id
+                  team_id_user_creator = team_creator + "_" + user_creator
+
+                  @active_chat_gpt_sessions[team_id_user_creator] ||= {}
+                  if @active_chat_gpt_sessions[team_id_user_creator].key?(Thread.current[:thread_ts])
+                    session_name = @active_chat_gpt_sessions[team_id_user_creator][Thread.current[:thread_ts]]
+                  elsif @active_chat_gpt_sessions[team_id_user_creator].key?(Thread.current[:dest])
+                    session_name = @active_chat_gpt_sessions[team_id_user_creator][Thread.current[:dest]]
+                  else
+                    session_name = ""
+                  end
+                end
+                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)
+                  @open_ai[team_id_user_creator][:chat_gpt][:sessions][session_name][:model] = model
+                  respond "Model for this session is now #{model}" unless dont_save_stats
+                  update_openai_sessions(session_name, team_id: team_creator, user_name: user_creator) unless session_name == ""
+                end
               end
             elsif model_selected.size > 1
-              respond "There are more than one model with that name. Please be more specific: #{model_selected.join(', ')}"
+              respond "There are more than one model with that name. Please be more specific: #{model_selected.join(", ")}"
             else
               respond "There is no model with that name."
             end