feat: emergencial commit

config/runtime.exs

@@ -91,6 +91,8 @@ if config_env() == :prod do
   config :gpt_talkerbot, :allowed_users, parse_env_list.("ALLOWED_USERS")
   config :gpt_talkerbot, :allowed_groups, parse_env_list.("ALLOWED_GROUPS")
   config :gpt_talkerbot, :openai_api_key, System.get_env("OPENAI_API_KEY", "")
+  config :gpt_talkerbot, :grok_api_key, System.get_env("GROK_API_KEY", "")
+  config :gpt_talkerbot, :owner_id, System.get_env("OWNER_ID", "")
   config :gpt_talkerbot, :default_prompt, System.get_env("DEFAULT_PROMPT", "")
   config :gpt_talkerbot, :telegram_api_key, System.get_env("TELEGRAM_API_KEY", "")
   config :gpt_talkerbot, :server_host, System.get_env("SERVER_HOST", "")

lib/gpt_talkerbot/application.ex

@@ -22,7 +22,8 @@ defmodule GptTalkerbot.Application do
       # {GptTalkerbot.Worker, arg}
 
       GptTalkerbot.RMQPublisher,
-      GptTalkerbot.BotProcessor
+      GptTalkerbot.BotProcessor,
+      GptTalkerbot.RuntimeEnvs.GenServer
     ]
 
     # See https://hexdocs.pm/elixir/Supervisor.html

lib/gpt_talkerbot/runtime_envs/genserver.ex

@@ -0,0 +1,62 @@
+defmodule GptTalkerbot.RuntimeEnvs.GenServer do
+  @moduledoc """
+  GenServer runtime environment configuration
+  """
+
+  use GenServer
+
+  def start_link(opts) do
+    GenServer.start_link(__MODULE__, opts, name: __MODULE__)
+  end
+
+  # Server Callbacks
+
+  @impl true
+  def init(_opts) do
+    openai_api_key = Application.get_env(:gpt_talkerbot, :openai_api_key, "")
+
+    grok_api_key = Application.get_env(:gpt_talkerbot, :grok_api_key, "")
+
+    state = %{
+      openai_api_key: openai_api_key,
+      grok_api_key: grok_api_key,
+      using: :openai
+    }
+
+    {:ok, state}
+  end
+
+  def get_current_service do
+    GenServer.call(__MODULE__, :get_current_service)
+  end
+
+  def set_current_service(service) when service in [:openai, :grok] do
+    GenServer.cast(__MODULE__, {:set_current_service, service})
+  end
+
+  def get_openai_api_key do
+    GenServer.call(__MODULE__, :get_openai_api_key)
+  end
+
+  def get_grok_api_key do
+    GenServer.call(__MODULE__, :get_grok_api_key)
+  end
+
+  @impl true
+  def handle_call(:get_current_service, _from, state) do
+    {:reply, state.using, state}
+  end
+
+  def handle_call(:get_openai_api_key, _from, state) do
+    {:reply, state.openai_api_key, state}
+  end
+
+  def handle_call(:get_grok_api_key, _from, state) do
+    {:reply, state.grok_api_key, state}
+  end
+
+  @impl true
+  def handle_cast({:set_current_service, service}, state) do
+    {:noreply, %{state | using: service}}
+  end
+end

lib/gpt_talkerbot/telegram/handlers/message_handler.ex

@@ -4,11 +4,11 @@ defmodule GptTalkerbot.Telegram.Handlers.MessageHandler do
   """
 
   alias GptTalkerbot.Telegram.Message
-  alias GptTalkerbotWeb.Services.{Telegram, OpenAI}
+  alias GptTalkerbotWeb.Services.{Grok, OpenAI, Telegram}
   alias GptTalkerbot.Access
+  alias GptTalkerbot.RuntimeEnvs.GenServer, as: RuntimeEnvs
 
   @behaviour GptTalkerbot.Telegram.Handlers
-  def api_key, do: Application.get_env(:gpt_talkerbot, :openai_api_key, "")
 
   @impl true
   def handle(
@@ -20,7 +20,8 @@ defmodule GptTalkerbot.Telegram.Handlers.MessageHandler do
       ) do
     with user <- Access.get_user_by_telegram_id!(user_id),
          {:ok, api_key} <- Access.get_key_for_user(user) do
-      process_gpt_message(api_key, user_id, []) # TODO: NEED TO BE REFACTORED
+      # TODO: NEED TO BE REFACTORED
+      process_gpt_message(api_key, user_id, [])
       |> case do
         {:ok, response} ->
           handle_gpt_response(response)
@@ -45,7 +46,8 @@ defmodule GptTalkerbot.Telegram.Handlers.MessageHandler do
       )
       when group in ["group_temp", "supergroup_temp"] do
     with {:ok, api_key} <- Access.get_key_for_group(chat_id) do
-      process_gpt_message(api_key, user_id, []) # TODO: NEED TO BE REFACTORED
+      # TODO: NEED TO BE REFACTORED
+      process_gpt_message(api_key, user_id, [])
       |> case do
         {:ok, response} ->
           handle_gpt_response(response)
@@ -63,12 +65,21 @@ defmodule GptTalkerbot.Telegram.Handlers.MessageHandler do
   def handle(
         %Message{
           text: text,
-          from: %{telegram_id: user_id},
-          reply_to_message: %{text: reply_text, from: %{telegram_id: reply_user_id}}
+          from: %{telegram_id: user_id, first_name: name},
+          reply_to_message:
+            %{
+              from: %{telegram_id: reply_user_id, first_name: reply_name}
+            } = reply_to_message
         } = message
       ) do
-    with messages <- build_messages([%{user: reply_user_id,  text: reply_text}, %{user: user_id, text: text}]),
-         {:ok, response} <- process_gpt_message(api_key(), user_id, messages) do
+    reply_text = reply_to_message.caption || reply_to_message.text
+
+    with messages <-
+           build_messages([
+             %{user: "user_name: #{reply_name}, user_id: #{reply_user_id}", text: reply_text},
+             %{user: "user_name: #{name}, user_id: #{user_id}", text: text}
+           ]),
+         {:ok, response} <- process_ai_message(user_id, messages) do
       handle_gpt_response(response)
       |> send_message(message)
     else
@@ -77,15 +88,15 @@ defmodule GptTalkerbot.Telegram.Handlers.MessageHandler do
     end
   end
 
-
   def handle(
         %Message{
           text: text,
-          from: %{telegram_id: user_id}
+          from: %{telegram_id: user_id, first_name: name}
         } = message
       ) do
-    with messages <- build_messages(%{user: user_id, text: text}),
-         {:ok, response} <- process_gpt_message(api_key(), user_id, messages) do
+    with messages <-
+           build_messages(%{user: "user_name: #{name}, user_id: #{user_id}", text: text}),
+         {:ok, response} <- process_ai_message(user_id, messages) do
       handle_gpt_response(response)
       |> send_message(message)
     else
@@ -94,12 +105,30 @@ defmodule GptTalkerbot.Telegram.Handlers.MessageHandler do
     end
   end
 
+  def process_ai_message(user_id, messages) do
+    case IO.inspect(RuntimeEnvs.get_current_service(), label: "the ai service is") do
+      :openai ->
+        openai_api_key = RuntimeEnvs.get_openai_api_key()
+        process_gpt_message(openai_api_key, user_id, messages)
+
+      :grok ->
+        grok_api_key = RuntimeEnvs.get_grok_api_key()
+        process_grok_message(grok_api_key, user_id, messages)
+    end
+  end
+
   defp process_gpt_message(api_key, user_id, messages) do
     api_key
     |> OpenAI.new()
     |> OpenAI.gpt_completion(user_id, messages)
   end
 
+  defp process_grok_message(api_key, user_id, messages) do
+    api_key
+    |> Grok.new()
+    |> Grok.grok_completion(user_id, messages)
+  end
+
   defp handle_gpt_response(response) do
     response
     |> Map.get("choices")
@@ -115,7 +144,6 @@ defmodule GptTalkerbot.Telegram.Handlers.MessageHandler do
     Telegram.send_message(%{chat_id: chat_id, text: text, reply_to_message_id: message_id})
   end
 
-
   def build_messages(%{user: user, text: text}) do
     [build_message(text, user)]
   end
@@ -126,6 +154,6 @@ defmodule GptTalkerbot.Telegram.Handlers.MessageHandler do
   end
 
   defp build_message(text, user) do
-    %{role: "user", content: "user #{user}: #{text}"}
+    %{role: "user", content: "#{user}, message: #{text}"}
   end
 end

lib/gpt_talkerbot/telegram/schemas/message.ex

@@ -27,6 +27,7 @@ defmodule GptTalkerbot.Telegram.Message do
       field :chat_type, :string
       field :chat_first_name, :string
       field :message_id, :string
+      field :caption, :string
       field :text, :string
       embeds_one :from, From
     end
@@ -38,6 +39,7 @@ defmodule GptTalkerbot.Telegram.Message do
     field :chat_id, :string
     field :chat_type, :string
     field :text, :string
+    field :caption, :string
 
     embeds_one :from, From
     embeds_one :reply_to_message, ReplyToMessage
@@ -54,7 +56,7 @@ defmodule GptTalkerbot.Telegram.Message do
 
   defp reply_to_message_changeset(schema, params) do
     schema
-    |> Changeset.cast(params, [:text, :chat_id, :chat_type, :chat_first_name])
+    |> Changeset.cast(params, [:text, :chat_id, :chat_type, :chat_first_name, :caption])
     |> put_fields(params)
     |> Changeset.cast_embed(:from, with: &from_changeset/2)
   end

lib/gpt_talkerbot_web/controllers/bot_controller.ex

@@ -8,13 +8,82 @@ defmodule GptTalkerbotWeb.BotController do
   alias GptTalkerbot.Commands
   alias BotController.Administrator
   alias GptTalkerbot.Commands
+  alias GptTalkerbot.RuntimeEnvs.GenServer, as: RuntimeEnvs
+
+  defp owner_id, do: Application.get_env(:gpt_talkerbot, :owner_id, "")
 
   @private_commands Administrator.private_commands()
   @group_commands Administrator.group_commands()
 
   defp allowed_users, do: Application.get_env(:gpt_talkerbot, :allowed_users, [])
   defp allowed_groups, do: Application.get_env(:gpt_talkerbot, :allowed_groups, [])
 
+  def receive(
+        conn,
+        %{
+          "message" =>
+            %{
+              "chat" => %{"id" => chat_id},
+              "text" => "/setproduction",
+              "from" => %{"id" => user_id}
+            } = _message
+        } = _params
+      ) do
+    if is_admin_allowed?(user_id, chat_id) do
+      GptTalkerbotWeb.Services.Telegram.set_production_mode()
+      send_resp(conn, 204, "")
+    else
+      send_resp(conn, 204, "")
+    end
+  rescue
+    _ ->
+      send_resp(conn, 204, "")
+  end
+
+  def receive(
+        conn,
+        %{
+          "message" =>
+            %{
+              "chat" => %{"id" => chat_id},
+              "text" => "/setgrok",
+              "from" => %{"id" => user_id}
+            } = _message
+        } = _params
+      ) do
+    if is_admin_allowed?(user_id, chat_id) do
+      RuntimeEnvs.set_current_service(:grok)
+      send_resp(conn, 204, "")
+    else
+      send_resp(conn, 204, "")
+    end
+  rescue
+    _ ->
+      send_resp(conn, 204, "")
+  end
+
+  def receive(
+        conn,
+        %{
+          "message" =>
+            %{
+              "chat" => %{"id" => chat_id},
+              "text" => "/setopenai",
+              "from" => %{"id" => user_id}
+            } = _message
+        } = _params
+      ) do
+    if is_admin_allowed?(user_id, chat_id) do
+      RuntimeEnvs.set_current_service(:openai)
+      send_resp(conn, 204, "")
+    else
+      send_resp(conn, 204, "")
+    end
+  rescue
+    _ ->
+      send_resp(conn, 204, "")
+  end
+
   def receive(
         conn,
         %{
@@ -31,6 +100,9 @@ defmodule GptTalkerbotWeb.BotController do
     else
       send_resp(conn, 204, "")
     end
+  rescue
+    _ ->
+      send_resp(conn, 204, "")
   end
 
   def receive(
@@ -49,6 +121,9 @@ defmodule GptTalkerbotWeb.BotController do
     else
       send_resp(conn, 204, "")
     end
+  rescue
+    _ ->
+      send_resp(conn, 204, "")
   end
 
   def receive(
@@ -82,6 +157,9 @@ defmodule GptTalkerbotWeb.BotController do
     end
 
     send_resp(conn, 204, "")
+  rescue
+    _ ->
+      send_resp(conn, 204, "")
   end
 
   def receive(
@@ -133,7 +211,11 @@ defmodule GptTalkerbotWeb.BotController do
     end
   end
 
+  defp is_admin_allowed?(owner_id, _) do
+    owner_id == owner_id()
+  end
+
   defp is_allowed?(user_id, chat_id) do
-    user_id in allowed_groups() or allowed_groups() == [] or chat_id in allowed_groups()
+    user_id in allowed_users() or allowed_groups() == [] or chat_id in allowed_groups()
   end
 end