Module: SlackSmartBot::Commands::General::AI::OpenAI

Included in:
SlackSmartBot
Defined in:
lib/slack/smart-bot/commands/general/ai/open_ai/open_ai_chat.rb,
lib/slack/smart-bot/commands/general/ai/open_ai/open_ai_models.rb,
lib/slack/smart-bot/commands/general/ai/open_ai/open_ai_whisper.rb,
lib/slack/smart-bot/commands/general/ai/open_ai/open_ai_edit_image.rb,
lib/slack/smart-bot/commands/general/ai/open_ai/open_ai_chat_use_model.rb,
lib/slack/smart-bot/commands/general/ai/open_ai/open_ai_generate_image.rb,
lib/slack/smart-bot/commands/general/ai/open_ai/open_ai_chat_get_prompts.rb,
lib/slack/smart-bot/commands/general/ai/open_ai/open_ai_variations_image.rb,
lib/slack/smart-bot/commands/general/ai/open_ai/open_ai_chat_copy_session.rb,
lib/slack/smart-bot/commands/general/ai/open_ai/open_ai_chat_list_sessions.rb,
lib/slack/smart-bot/commands/general/ai/open_ai/open_ai_chat_share_session.rb,
lib/slack/smart-bot/commands/general/ai/open_ai/open_ai_chat_delete_session.rb,
lib/slack/smart-bot/commands/general/ai/open_ai/open_ai_chat_add_collaborator.rb

Instance Method Summary collapse

Instance Method Details

#open_ai_chat(message, delete_history, type, model: '', tag: '', description: '', files: []) ⇒ Object 



6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
 
# File 'lib/slack/smart-bot/commands/general/ai/open_ai/open_ai_chat.rb', line 6

def open_ai_chat(message, delete_history, type, model: '', tag: '', description: '', files: [])
  get_personal_settings()
  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
      @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
        unreact :speech_balloon
      end
    end
  end
end

#open_ai_chat_add_collaborator(cname) ⇒ Object 



6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
 
# File 'lib/slack/smart-bot/commands/general/ai/open_ai/open_ai_chat_add_collaborator.rb', line 6

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

#open_ai_chat_copy_session(team_orig, user_orig, session_name, new_session_name) ⇒ Object 



6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
 
# File 'lib/slack/smart-bot/commands/general/ai/open_ai/open_ai_chat_copy_session.rb', line 6

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

#open_ai_chat_delete_session(session_name) ⇒ Object 



6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
 
# File 'lib/slack/smart-bot/commands/general/ai/open_ai/open_ai_chat_delete_session.rb', line 6

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

#open_ai_chat_get_prompts(session_name) ⇒ Object 



6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
 
# File 'lib/slack/smart-bot/commands/general/ai/open_ai/open_ai_chat_get_prompts.rb', line 6

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

#open_ai_chat_list_sessions(type, tag: '') ⇒ Object

type can be :own or :public or :shared



6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
 
# File 'lib/slack/smart-bot/commands/general/ai/open_ai/open_ai_chat_list_sessions.rb', line 6

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

#open_ai_chat_share_session(type, session_name, channel_id) ⇒ Object 



6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
 
# File 'lib/slack/smart-bot/commands/general/ai/open_ai/open_ai_chat_share_session.rb', line 6

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

#open_ai_chat_use_model(model, dont_save_stats: false) ⇒ Object 



6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
 
# File 'lib/slack/smart-bot/commands/general/ai/open_ai/open_ai_chat_use_model.rb', line 6

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

#open_ai_edit_image(message, files) ⇒ Object 



6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
 
# File 'lib/slack/smart-bot/commands/general/ai/open_ai/open_ai_edit_image.rb', line 6

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, service: :dall_e)
  respond message_connect if message_connect
  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[team_id_user] ||= []
    react :art
    begin
      @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/#{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[team_id_user][:dall_e].client, image, message, size: @ai_open_ai[team_id_user][:dall_e][:image_size])

        if success
          urls = res
          urls = [urls] if urls.is_a?(String)
          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[team_id_user].empty?
              session_name = "Edit"
            else
              session_name = @ai_open_ai_image[team_id_user].first[0..29]
            end
            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/#{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?
            end
          end
        else
          respond res
        end
      end
    rescue => exception
      respond "*OpenAI*: Sorry, I'm having some problems. OpenAI probably is not available. Please try again later."
      @logger.warn exception
    end
    unreact :art
  end
end

#open_ai_generate_image(message, delete_history = false, repeat: false) ⇒ Object 



6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
 
# File 'lib/slack/smart-bot/commands/general/ai/open_ai/open_ai_generate_image.rb', line 6

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, service: :dall_e)
  respond message_connect if message_connect
  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[team_id_user] ||= []
    react :art
    begin
      @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[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[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[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|
              uri = URI.parse(url)
              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/#{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"
              else
                send_file(Thread.current[:dest], messagersp, file_path_name, message, "image/png", "png")
              end
              http.close unless http.nil?
            end
          end
        else
          respond res
        end
      end
    rescue => exception
      respond "*OpenAI*: Sorry, I'm having some problems. OpenAI probably is not available. Please try again later."
      @logger.warn exception
    end
    unreact :art
  end
end

#open_ai_models(model = '', just_models: false) ⇒ Object 



6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
 
# File 'lib/slack/smart-bot/commands/general/ai/open_ai/open_ai_models.rb', line 6

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, service: :models)
  respond message_connect if message_connect
  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[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
          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 unless just_models
  end
end

#open_ai_variations_image(message, variations, files) ⇒ Object 



6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
 
# File 'lib/slack/smart-bot/commands/general/ai/open_ai/open_ai_variations_image.rb', line 6

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, service: :dall_e)
  respond message_connect if message_connect
  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[team_id_user] ||= []
      react :art
      begin
        @ai_open_ai_image[team_id_user] = [] if !files.nil? and 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/#{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[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[team_id_user][:dall_e].client, image, variations, size: @ai_open_ai[team_id_user][:dall_e][:image_size])
          end
          if success
            urls = res
            urls = [urls] if urls.is_a?(String)
            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[team_id_user].empty?
                session_name = "Temporary Variation"
              else
                session_name = @ai_open_ai_image[team_id_user].first[0..29]
              end
              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/#{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
                  respond "file: #{file_path_name}, #{messagersp}, #{message}, image/png, png"
                else
                  send_file(Thread.current[:dest], messagersp, file_path_name, message, "image/png", "png")
                end
                http.close unless http.nil?
              end
            end
          else
            respond res
          end
        end
      rescue => exception
        respond "*OpenAI*: Sorry, I'm having some problems. OpenAI probably is not available. Please try again later."
        @logger.warn exception
      end
      unreact :art
    end
  end

  if variations > 9
    respond "*OpenAI*: I'm sorry, I can only generate up to 9 variations at a time. Please try again."
  else
  end
end

#open_ai_whisper(message, files) ⇒ Object 



6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
 
# File 'lib/slack/smart-bot/commands/general/ai/open_ai/open_ai_whisper.rb', line 6

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, service: :whisper)
  respond message_connect if message_connect
  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/#{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[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[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"
          end
          if res.size > 3000
            send_file(Thread.current[:dest], "*OpenAI Whisper*", '', type_whisper, "text/plain", "text", content: res)
          else
            respond "*OpenAI Whisper* \n#{res.strip}"
          end
        else
          respond "*OpenAI Whisper* \n#{res.strip}"
        end
        File.delete(audio) if File.exist?(audio)
      end
    rescue => exception
      respond "*OpenAI Whisper*: Sorry, I'm having some problems. OpenAI probably is not available. Please try again later."
      @logger.warn exception
    end
    unreact :speech_balloon
  end
end