slack-smart-bot 1.14.1 → 1.15.0

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

@@ -0,0 +1,41 @@
+class SlackSmartBot
+  module Commands
+    module General
+      module AI
+        module OpenAI
+          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
+                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
+              end
+            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

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

@@ -0,0 +1,81 @@
+class SlackSmartBot
+  module Commands
+    module General
+      module AI
+        module OpenAI
+          def open_ai_chat_list_sessions(type, tag: '') #type can be :own or :public or :shared
+            save_stats(__method__)
+
+            user = Thread.current[:user].dup
+            team_id = user.team_id
+            team_id_user = Thread.current[:team_id_user]
+
+            channel = Thread.current[:dest]
+
+            get_openai_sessions()
+            check_users = []
+            if type == :own
+              check_users << team_id_user
+            else
+              check_users = @open_ai.keys
+            end
+
+            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
+
+                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 == :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
+                      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")}"
+              end
+            else
+              if type == :own
+                respond "*ChatGPT*: You don't have any#{" >*#{tag}*" if tag!=''} sessions."
+              else
+                respond "*ChatGPT*: There are no#{" >*#{tag}*" if tag!=''} #{type} sessions."
+              end
+            end
+
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,52 @@
+class SlackSmartBot
+  module Commands
+    module General
+      module AI
+        module OpenAI
+          def open_ai_chat_share_session(type, session_name, channel_id)
+            save_stats(__method__)
+
+            user = Thread.current[:user].dup
+            team_id_user = Thread.current[:team_id_user]
+
+            @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)
+              if type == :share
+                if channel_id == ""
+                  @open_ai[team_id_user][:chat_gpt][:sessions][session_name].public = true
+                else
+                  @open_ai[team_id_user][:chat_gpt][:sessions][session_name].shared ||= []
+                  @open_ai[team_id_user][:chat_gpt][:sessions][session_name].shared << channel_id
+                end
+              elsif type == :stop
+                if channel_id == ""
+                  @open_ai[team_id_user][:chat_gpt][:sessions][session_name].public = false
+                else
+                  @open_ai[team_id_user][:chat_gpt][:sessions][session_name].shared.delete(channel_id)
+                end
+              end
+              update_openai_sessions()
+              if type == :share
+                if channel_id == ""
+                  respond "*ChatGPT*: Session *#{session_name}* is now public."
+                else
+                  respond "*ChatGPT*: Session *#{session_name}* is now shared on <##{channel_id}>."
+                end
+              elsif type == :stop
+                if channel_id == ""
+                  respond "*ChatGPT*: Session *#{session_name}* is no longer public."
+                else
+                  respond "*ChatGPT*: Session *#{session_name}* is no longer shared on <##{channel_id}>."
+                end
+              end
+            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

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

@@ -0,0 +1,52 @@
+class SlackSmartBot
+  module Commands
+    module General
+      module AI
+        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?
+            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 = ''
+                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
+            elsif model_selected.size > 1
+              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
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -6,23 +6,26 @@ class SlackSmartBot
           def open_ai_edit_image(message, files)
             save_stats(__method__)
             get_personal_settings()
-            @ai_open_ai, message_connect = SlackSmartBot::AI::OpenAI.connect(@ai_open_ai, config, @personal_settings)
+            @ai_open_ai, message_connect = SlackSmartBot::AI::OpenAI.connect(@ai_open_ai, config, @personal_settings, service: :dall_e)
             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?
+            user = Thread.current[:user].dup
+            team_id = user.team_id 
+            team_id_user = Thread.current[:team_id_user]
+
+            if !@ai_open_ai[team_id_user].nil? and !@ai_open_ai[team_id_user][:dall_e][:client].nil?
               @ai_open_ai_image ||= {}
-              @ai_open_ai_image[user.name] ||= []
+              @ai_open_ai_image[team_id_user] ||= []
               react :art
               begin
-                @ai_open_ai_image[user.name] = [] if !files.nil? and files.size == 1
+                @ai_open_ai_image[team_id_user] = [] if !files.nil? and files.size == 1
                 if files.nil? or files.size != 1
                   respond "*OpenAI*: Sorry, I need an image to edit. Please upload an image and try again."
                 else
                   require "nice_http"
-                  image = "#{config.path}/tmp/#{user.name}_#{@ai_open_ai_image[user.name].object_id}.png"
+                  image = "#{config.path}/tmp/#{team_id_user}_#{@ai_open_ai_image[team_id_user].object_id}.png"
                   http = NiceHttp.new(host: "https://files.slack.com", headers: { "Authorization" => "Bearer #{config.token}" })
                   res = http.get(files[0].url_private_download, save_data: image)
-                  success, res = SlackSmartBot::AI::OpenAI.send_image_edit(@ai_open_ai[user.name].client, image, message, size: @ai_open_ai[user.name][:image_size])
+                  success, res = SlackSmartBot::AI::OpenAI.send_image_edit(@ai_open_ai[team_id_user][:dall_e].client, image, message, size: @ai_open_ai[team_id_user][:dall_e][:image_size])
 
                   if success
                     urls = res
@@ -30,19 +33,19 @@ class SlackSmartBot
                     if urls.nil? or urls.empty?
                       respond "*OpenAI*: Sorry, I'm having some problems. OpenAI was not able to generate an image."
                     else
-                      if @ai_open_ai_image[user.name].empty?
+                      if @ai_open_ai_image[team_id_user].empty?
                         session_name = "Edit"
                       else
-                        session_name = @ai_open_ai_image[user.name].first[0..29]
+                        session_name = @ai_open_ai_image[team_id_user].first[0..29]
                       end
-                      messagersp = "OpenAI Session: _<#{session_name}...>_ (id:#{@ai_open_ai_image[user.name].object_id})"
+                      messagersp = "OpenAI Session: _<#{session_name}...>_ (id:#{@ai_open_ai_image[team_id_user].object_id})"
                       message = "Edit"
                       require "uri"
                       urls.each do |url|
                         uri = URI.parse(url)
                         require "nice_http"
                         http = NiceHttp.new(host: "https://#{uri.host}")
-                        file_path_name = "#{config.path}/tmp/#{user.name}_#{@ai_open_ai_image[user.name].object_id}.png"
+                        file_path_name = "#{config.path}/tmp/#{team_id_user}_#{@ai_open_ai_image[team_id_user].object_id}.png"
                         res = http.get(uri.path + "?#{uri.query}", save_data: file_path_name)
                         send_file(Thread.current[:dest], messagersp, file_path_name, message, "image/png", "png")
                         http.close unless http.nil?

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

@@ -6,30 +6,34 @@ class SlackSmartBot
           def open_ai_generate_image(message, delete_history = false, repeat: false)
             save_stats(__method__)
             get_personal_settings()
-            @ai_open_ai, message_connect = SlackSmartBot::AI::OpenAI.connect(@ai_open_ai, config, @personal_settings, reconnect: delete_history)
+            @ai_open_ai, message_connect = SlackSmartBot::AI::OpenAI.connect(@ai_open_ai, config, @personal_settings, reconnect: delete_history, service: :dall_e)
             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?
+            user = Thread.current[:user].dup
+            team_id = user.team_id 
+            team_id_user = Thread.current[:team_id_user]
+
+            if !@ai_open_ai[team_id_user].nil? and !@ai_open_ai[team_id_user][:dall_e][:client].nil?
               @ai_open_ai_image ||= {}
-              @ai_open_ai_image[user.name] ||= []
+              @ai_open_ai_image[team_id_user] ||= []
               react :art
               begin
-                @ai_open_ai_image[user.name] = [] if delete_history
+                @ai_open_ai_image[team_id_user] = [] if delete_history
                 if delete_history and message == ""
                   respond "*OpenAI*: Let's start a new image generation. Use `?i PROMPT` to generate an image."
-                elsif repeat and @ai_open_ai_image[user.name].empty? and message == ""
+                elsif repeat and @ai_open_ai_image[team_id_user].empty? and message == ""
                   respond "*OpenAI*: Sorry, I need to generate an image first. Use `?i PROMPT` to generate an image."
                 else
-                  @ai_open_ai_image[user.name] << message unless repeat
-                  success, res = SlackSmartBot::AI::OpenAI.send_image_generation(@ai_open_ai[user.name][:client], @ai_open_ai_image[user.name].join("\n"), @ai_open_ai[user.name][:image_size])
+                  @ai_open_ai_image[team_id_user] << message unless repeat
+                  success, res = SlackSmartBot::AI::OpenAI.send_image_generation(@ai_open_ai[team_id_user][:dall_e][:client], @ai_open_ai_image[team_id_user].join("\n"), @ai_open_ai[team_id_user][:dall_e][:image_size])
                   if success
                     urls = res
                     urls = [urls] if urls.is_a?(String)
+                    urls.delete({})
                     if urls.nil? or urls.empty?
                       respond "*OpenAI*: Sorry, I'm having some problems. OpenAI was not able to generate an image."
                     else
-                      session_name = @ai_open_ai_image[user.name].first[0..29]
-                      messagersp = "OpenAI Session: _<#{session_name}...>_ (id:#{@ai_open_ai_image[user.name].object_id})"
+                      session_name = @ai_open_ai_image[team_id_user].first[0..29]
+                      messagersp = "OpenAI Session: _<#{session_name}...>_ (id:#{@ai_open_ai_image[team_id_user].object_id})"
                       message = "Repeat" if repeat
                       require "uri"
                       urls.each do |url|
@@ -37,7 +41,7 @@ class SlackSmartBot
                         require "nice_http"
                         http = NiceHttp.new(host: "https://#{uri.host}")
                         Dir.mkdir("#{config.path}/tmp") unless Dir.exist?("#{config.path}/tmp")
-                        file_path_name = "#{config.path}/tmp/#{user.name}_#{@ai_open_ai_image[user.name].object_id}.png"
+                        file_path_name = "#{config.path}/tmp/#{team_id_user}_#{@ai_open_ai_image[team_id_user].object_id}.png"
                         res = http.get(uri.path + "?#{uri.query}", save_data: file_path_name)
                         if config.simulate
                           respond "file: #{file_path_name}, #{messagersp}, #{message}, image/png, png"

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

@@ -3,31 +3,43 @@ class SlackSmartBot
     module General
       module AI
         module OpenAI
-          def open_ai_models(model='')
-            save_stats(__method__)
+          def open_ai_models(model='', just_models: false)
+            save_stats(__method__) unless just_models
             get_personal_settings()
-            @ai_open_ai, message_connect = SlackSmartBot::AI::OpenAI.connect(@ai_open_ai, config, @personal_settings)
+            @ai_open_ai, message_connect = SlackSmartBot::AI::OpenAI.connect(@ai_open_ai, config, @personal_settings, service: :models)
             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?
-                react :running
+            user = Thread.current[:user].dup
+            team_id = user.team_id
+            team_id_user = Thread.current[:team_id_user]
+            if !@ai_open_ai[team_id_user].nil? and !@ai_open_ai[team_id_user][:models][:client].nil?
+                react :running unless just_models
                 begin
-                  res = SlackSmartBot::AI::OpenAI.models(@ai_open_ai[user.name][:client], model)
-                  if model == ''
-                    message = ["*OpenAI*"]
-                    message << "If you want to use a model, you can use on a DM with the SmartBot the command"
-                    message << "`set personal settings ai.open_ai.gpt_model MODEL_NAME`"
-                    message << "`set personal settings ai.open_ai.whisper_model MODEL_NAME`"
-                    message << "Here are the models available for use:"
-                    message << "```#{res.strip}```"
-                    respond message.join("\n")
+                  res = SlackSmartBot::AI::OpenAI.models(@ai_open_ai[team_id_user][:models][:client], @ai_open_ai[team_id_user][:models], model)
+                  if model == '' or model == 'chatgpt'
+                    unless just_models
+                      message = ["*OpenAI*"]
+                      message << "To start a chatGPT session using a specific model: `^chatgpt SESSION_NAME MODEL_NAME`"
+                      message << "For example: `^chatgpt data_analysis gpt-35-turbo-0301`"
+                      message << "If you want to use a model by default, you can use on a DM with the SmartBot the command"
+                      message << "`set personal settings ai.open_ai.chat_gpt.model MODEL_NAME`"
+                      message << "`set personal settings ai.open_ai.whisper.model MODEL_NAME`" if model == ''
+                      message << "Here are the #{"#{model} " if model!=''}models available for use:"
+                      message << "```#{res.strip}```"
+                      respond message.join("\n")
+                    end
+                    @open_ai_models = res.split("\n") if model == ''
                   else
-                    respond "*OpenAI* Info about #{model} model:\n```#{res.strip}```"
+                    if just_models
+                      return res
+                    else
+                      respond "*OpenAI* Info about #{model} model:\n```#{res.strip}```"
+                    end
                   end
                 rescue => exception
+                  @logger.warn "Error in open_ai_models: #{exception}"
                   respond "*OpenAI*: Sorry, I'm having some problems. OpenAI probably is not available. Please try again later."
                 end
-                unreact :running
+                unreact :running unless just_models
             end
           end
         end

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

@@ -6,31 +6,34 @@ class SlackSmartBot
           def open_ai_variations_image(message, variations, files)
             save_stats(__method__)
             get_personal_settings()
-            @ai_open_ai, message_connect = SlackSmartBot::AI::OpenAI.connect(@ai_open_ai, config, @personal_settings)
+            @ai_open_ai, message_connect = SlackSmartBot::AI::OpenAI.connect(@ai_open_ai, config, @personal_settings, service: :dall_e)
             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?
+            user = Thread.current[:user].dup
+            team_id = user.team_id 
+            team_id_user = Thread.current[:team_id_user]
+
+            if !@ai_open_ai[team_id_user].nil? and !@ai_open_ai[team_id_user][:dall_e][:client].nil?
               if variations > 9
                 respond "*OpenAI*: I'm sorry, I can only generate up to 9 variations at a time. Please try again."
               else
                 variations = 1 if variations == 0
                 @ai_open_ai_image ||= {}
-                @ai_open_ai_image[user.name] ||= []
+                @ai_open_ai_image[team_id_user] ||= []
                 react :art
                 begin
-                  @ai_open_ai_image[user.name] = [] if !files.nil? and files.size == 1
+                  @ai_open_ai_image[team_id_user] = [] if !files.nil? and files.size == 1
 
-                  if (!File.exist?("#{config.path}/tmp/#{user.name}_#{@ai_open_ai_image[user.name].object_id}.png") and (files.nil? or files.size != 1))
+                  if (!File.exist?("#{config.path}/tmp/#{team_id_user}_#{@ai_open_ai_image[team_id_user].object_id}.png") and (files.nil? or files.size != 1))
                     respond "*OpenAI*: Sorry, I need to generate an image first. Use `?i PROMPT` to generate an image or upload an image to generate variations."
                   else
-                    image = "#{config.path}/tmp/#{user.name}_#{@ai_open_ai_image[user.name].object_id}.png"
+                    image = "#{config.path}/tmp/#{team_id_user}_#{@ai_open_ai_image[team_id_user].object_id}.png"
                     if !files.nil? and files.size == 1
                       require "nice_http"
                       http = NiceHttp.new(host: "https://files.slack.com", headers: { "Authorization" => "Bearer #{config.token}" })
                       res = http.get(files[0].url_private_download, save_data: image)
-                      success, res = SlackSmartBot::AI::OpenAI.send_image_variation(@ai_open_ai[user.name].client, image, variations, size: @ai_open_ai[user.name][:image_size])
+                      success, res = SlackSmartBot::AI::OpenAI.send_image_variation(@ai_open_ai[team_id_user][:dall_e].client, image, variations, size: @ai_open_ai[team_id_user][:dall_e][:image_size])
                     else
-                      success, res = SlackSmartBot::AI::OpenAI.send_image_variation(@ai_open_ai[user.name].client, image, variations, size: @ai_open_ai[user.name][:image_size])
+                      success, res = SlackSmartBot::AI::OpenAI.send_image_variation(@ai_open_ai[team_id_user][:dall_e].client, image, variations, size: @ai_open_ai[team_id_user][:dall_e][:image_size])
                     end
                     if success
                       urls = res
@@ -38,18 +41,18 @@ class SlackSmartBot
                       if urls.nil? or urls.empty?
                         respond "*OpenAI*: Sorry, I'm having some problems. OpenAI was not able to generate an image."
                       else
-                        if @ai_open_ai_image[user.name].empty?
+                        if @ai_open_ai_image[team_id_user].empty?
                           session_name = "Temporary Variation"
                         else
-                          session_name = @ai_open_ai_image[user.name].first[0..29]
+                          session_name = @ai_open_ai_image[team_id_user].first[0..29]
                         end
-                        messagersp = "OpenAI Session: _<#{session_name}...>_ (id:#{@ai_open_ai_image[user.name].object_id})"
+                        messagersp = "OpenAI Session: _<#{session_name}...>_ (id:#{@ai_open_ai_image[team_id_user].object_id})"
                         require "uri"
                         urls.each do |url|
                           uri = URI.parse(url)
                           require "nice_http"
                           http = NiceHttp.new(host: "https://#{uri.host}")
-                          file_path_name = "#{config.path}/tmp/#{user.name}_#{@ai_open_ai_image[user.name].object_id}.png"
+                          file_path_name = "#{config.path}/tmp/#{team_id_user}_#{@ai_open_ai_image[team_id_user].object_id}.png"
                           res = http.get(uri.path + "?#{uri.query}", save_data: file_path_name)
                           message = "Variation #{urls.index(url)+1} of #{urls.size}"
                           if config.simulate

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

@@ -6,23 +6,29 @@ class SlackSmartBot
           def open_ai_whisper(message, files)
             save_stats(__method__)
             get_personal_settings()
-            @ai_open_ai, message_connect = SlackSmartBot::AI::OpenAI.connect(@ai_open_ai, config, @personal_settings)
+            @ai_open_ai, message_connect = SlackSmartBot::AI::OpenAI.connect(@ai_open_ai, config, @personal_settings, service: :whisper)
             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?
-              react :speech_balloon 
+            user = Thread.current[:user].dup
+            team_id = user.team_id
+            team_id_user = Thread.current[:team_id_user]
+
+            if !@ai_open_ai[team_id_user].nil? and !@ai_open_ai[team_id_user][:whisper][:client].nil?
+              react :speech_balloon
               begin
                 if files.nil? or files.size != 1
                   respond "*OpenAI Whisper*: Sorry, I need an audio file to transcribe. Please upload an audio file and try again."
                 else
                   require "nice_http"
-                  audio = "#{config.path}/tmp/#{user.name}_audio.wav"
+                  audio = "#{config.path}/tmp/#{team_id_user}_audio.wav"
                   http = NiceHttp.new(host: "https://files.slack.com", headers: { "Authorization" => "Bearer #{config.token}" })
+                  #todo: in case using a channel with external people from other organizations files are treated differently. We need to take in consideration that
+                  #https://api.slack.com/types/file#slack_connect_files
+                  #This is for all files in all commands
                   res = http.get(files[0].url_private_download, save_data: audio)
-                  success, res = SlackSmartBot::AI::OpenAI.whisper_transcribe(@ai_open_ai[user.name][:client], @ai_open_ai[user.name].whisper_model, audio)
+                  success, res = SlackSmartBot::AI::OpenAI.whisper_transcribe(@ai_open_ai[team_id_user][:whisper][:client], @ai_open_ai[team_id_user].whisper.model, audio)
                   if success
                     if message.to_s != ''
-                      success, res = SlackSmartBot::AI::OpenAI.send_gpt_chat(@ai_open_ai[user.name][:client], @ai_open_ai[user.name].gpt_model, "#{message}:\n#{res}")
+                      success, res = SlackSmartBot::AI::OpenAI.send_gpt_chat(@ai_open_ai[team_id_user][:whisper][:client], @ai_open_ai[team_id_user].chat_gpt.model, "#{message}:\n#{res}", @ai_open_ai[team_id_user].chat_gpt)
                       type_whisper = message
                     else
                       type_whisper = "Transcribe"

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

@@ -4,7 +4,7 @@ class SlackSmartBot
     not_allowed = ["hi_bot", "bye_bot", "allow_access", "deny_access", "get_bot_logs", "add_routine", "pause_bot", "pause_routine", "remove_routine", "run_routine", "start_bot",
                    "start_routine", "delete_message", "update_message", "send_message", "kill_bot_on_channel", "exit_bot", "notify_message", "publish_announcements", "set_general_message",
                    "set_maintenance", "bot_help", "bot_rules"]
-    if !is_admin?(user.name)
+    if !is_admin?(user)
       respond "Only admins of this channel can use this command. Take a look who is an admin of this channel by calling `see admins`"
     elsif Thread.current[:dest][0] == "D"
       respond "This command cannot be called from a DM"
@@ -43,11 +43,13 @@ class SlackSmartBot
               @access_channels[channel][command_id] = []
             end
             access_users_names = []
+            access_team_id_users_names = []
             access_users.each do |us|
-              user_info = @users.select { |u| u.id == us or (u.key?(:enterprise_user) and u.enterprise_user.id == us) }[-1]
+              user_info = find_user(us)
               access_users_names << user_info.name unless user_info.nil?
+              access_team_id_users_names << "#{user_info.team_id}_#{user_info.name}" unless user_info.nil?
             end
-            @access_channels[channel][command_id] += access_users_names
+            @access_channels[channel][command_id] += access_team_id_users_names
             @access_channels[channel][command_id].flatten!
             @access_channels[channel][command_id].uniq!
             @access_channels[channel][command_id].delete(nil)
@@ -56,7 +58,9 @@ class SlackSmartBot
           if !@access_channels[channel].key?(command_id)
             respond "All users will have access to this command on this channel."
           else
-            respond "These users will have access to this command on this channel: <@#{@access_channels[channel][command_id].join(">, <@")}>"
+            # get the names of the users. The value of the hash is the team_id_user_name
+            names = @access_channels[channel][command_id].map { |u| u.split("_")[1..-1].join("_") }
+            respond "These users will have access to this command on this channel: <@#{names.join(">, <@")}>"
           end
         end
       else

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

@@ -1,11 +1,10 @@
 class SlackSmartBot
 
-  def bot_help(user, from, dest, dchannel, specific, help_command, rules_file, savestats: true, strict: false)
+  def bot_help(user, from, dest, dchannel, specific, help_command, rules_file, savestats: true, strict: false, send_to_file: false)
     save_stats(__method__) if savestats
     output = []
     if has_access?(__method__, user)
       help_found = false
-
       message = ""
       if help_command.to_s != ''
         help_command = '' if help_command.to_s.match?(/^\s*expanded\s*$/i) or help_command.to_s.match?(/^\s*extended\s*$/i)
@@ -16,7 +15,12 @@ class SlackSmartBot
         message_not_expanded = "If you want to see the *expanded* version of *`bot help`* or *`bot rules`*, please call *`bot help expanded`* or *`bot rules expanded`*\n"
         message_not_expanded += "Also to get specific *expanded* help for a specific command or rule call *`bot help COMMAND`*\n"
       end
-      help_message = get_help(rules_file, dest, from, specific, expanded)
+      expanded = true if Thread.current[:prompt].to_s != ''
+      if send_to_file
+          expanded = true
+          message_not_expanded = ''
+      end
+      help_message = get_help(rules_file, dest, user, specific, expanded)
       commands = []
       commands_search = []
       if help_command.to_s != ""
@@ -39,7 +43,7 @@ class SlackSmartBot
               help_command.to_s.split(' ') do |hc|
                 unless hc.match?(/^\s*\z/)
                   if !h.match?(/#{hc}/i)
-                    all_found = false                  
+                    all_found = false
                   end
                 end
               end
@@ -110,14 +114,25 @@ class SlackSmartBot
         output << message_not_expanded
       end
     end
-    if output.join("\n").lines.count > 50 and dest[0]!='D'
+    if output.join("\n").lines.count > 50 and dest[0]!='D' and !send_to_file
       dest = :on_thread
       output.unshift('Since there are many lines returned the results are returned on a thread by default.')
     end
-    output.each do |h|
-      msg = h.gsub(/^\s*command_id:\s+:\w+\s*$/,'')
-      unless msg.match?(/\A\s*\z/)
-        respond msg, dest, unfurl_links: false, unfurl_media: false
+    if send_to_file
+      content = output.join("\n\n")
+      content.gsub!(/\*<([^>]*)\|([^>]*)>\*/, '## [\2](\1)')
+      content.gsub!(/^\s*(\*.+\*)\s*$/, '# \1')
+      content.gsub!(/command_id:\s+:/, '### :')
+      content = content.gsub("\n", "  \n").gsub(/\|[\w\s]*>/i,">").gsub(/^\s*\-\-\-\-\-\-/, "\n------")
+      dest == :on_thread ? dest_file = dchannel : dest_file = dest
+      send_file(dest_file, "SmartBot Help", "", 'smartbot_help.md', "text/markdown", "markdown", content: content)
+    else
+      output.each do |h|
+        msg = h.gsub(/^\s*command_id:\s+:\w+\s*$/,'')
+        msg.gsub!(/^\s*>.+$/,'') if help_command.to_s != ''
+        unless msg.match?(/\A\s*\z/)
+          respond msg, dest, unfurl_links: false, unfurl_media: false
+        end
       end
     end
     return output.join("\n")