working on providers

lib/elixir_ai/application.ex

@@ -7,6 +7,7 @@ defmodule ElixirAi.Application do
     children = [
       ElixirAiWeb.Telemetry,
       ElixirAi.Repo,
+      {Task, fn -> ElixirAi.AiProvider.ensure_default_provider() end},
       {Cluster.Supervisor,
        [Application.get_env(:libcluster, :topologies, []), [name: ElixirAi.ClusterSupervisor]]},
       {Phoenix.PubSub, name: ElixirAi.PubSub},

lib/elixir_ai/chat_runner.ex

@@ -45,7 +45,10 @@ defmodule ElixirAi.ChatRunner do
        messages: messages,
        streaming_response: nil,
        pending_tool_calls: [],
-       tools: tools(self(), name)
+       tools: tools(self(), name),
+       ai_provider_url: Application.get_env(:elixir_ai, :ai_provider_url),
+       ai_model: Application.get_env(:elixir_ai, :ai_model),
+       ai_token: Application.get_env(:elixir_ai, :ai_token),
      }}
   end
 

lib/elixir_ai/conversation_manager.ex

@@ -17,13 +17,13 @@ defmodule ElixirAi.ConversationManager do
   end
 
   def init(_) do
-    names = Conversation.all_names()
-    conversations = Map.new(names, fn name -> {name, []} end)
+    conversation_list = Conversation.all_names()
+    conversations = Map.new(conversation_list, fn %{name: name} -> {name, []} end)
     {:ok, conversations}
   end
 
-  def create_conversation(name) do
-    GenServer.call(@name, {:create, name})
+  def create_conversation(name, ai_provider_id) do
+    GenServer.call(@name, {:create, name, ai_provider_id})
   end
 
   def open_conversation(name) do
@@ -38,11 +38,11 @@ defmodule ElixirAi.ConversationManager do
     GenServer.call(@name, {:get_messages, name})
   end
 
-  def handle_call({:create, name}, _from, conversations) do
+  def handle_call({:create, name, ai_provider_id}, _from, conversations) do
     if Map.has_key?(conversations, name) do
       {:reply, {:error, :already_exists}, conversations}
     else
-      case Conversation.create(name) do
+      case Conversation.create(name, ai_provider_id) do
         :ok ->
           case start_and_subscribe(name) do
             {:ok, _pid} = ok -> {:reply, ok, Map.put(conversations, name, [])}
@@ -75,8 +75,6 @@ defmodule ElixirAi.ConversationManager do
   end
 
   def handle_info({:store_message, name, message}, conversations) do
-    messages = Map.get(conversations, name, [])
-
     case Conversation.find_id(name) do
       {:ok, conv_id} -> Message.insert(conv_id, message)
       _ -> :ok

lib/elixir_ai/data/ai_provider.ex

@@ -0,0 +1,89 @@
+defmodule ElixirAi.AiProvider do
+  import Ecto.Query
+  alias ElixirAi.Repo
+
+  def all do
+    Repo.all(
+      from(p in "ai_providers",
+        select: %{
+          id: p.id,
+          name: p.name,
+          model_name: p.model_name,
+          api_token: p.api_token,
+          completions_url: p.completions_url
+        }
+      )
+    )
+  end
+
+  def create(attrs) do
+    now = DateTime.truncate(DateTime.utc_now(), :second)
+
+    case Repo.insert_all("ai_providers", [
+           [
+             name: attrs.name,
+             model_name: attrs.model_name,
+             api_token: attrs.api_token,
+             completions_url: attrs.completions_url,
+             inserted_at: now,
+             updated_at: now
+           ]
+         ]) do
+      {1, _} ->
+        Phoenix.PubSub.broadcast(
+          ElixirAi.PubSub,
+          "ai_providers",
+          {:provider_added, attrs}
+        )
+
+        :ok
+
+      _ ->
+        {:error, :db_error}
+    end
+  rescue
+    e in Ecto.ConstraintError ->
+      if e.constraint == "ai_providers_name_key",
+        do: {:error, :already_exists},
+        else: {:error, :db_error}
+  end
+
+  def find_by_name(name) do
+    case Repo.one(
+           from(p in "ai_providers",
+             where: p.name == ^name,
+             select: %{
+               id: p.id,
+               name: p.name,
+               model_name: p.model_name,
+               api_token: p.api_token,
+               completions_url: p.completions_url
+             }
+           )
+         ) do
+      nil -> {:error, :not_found}
+      provider -> {:ok, provider}
+    end
+  end
+
+  def ensure_default_provider do
+    case Repo.aggregate(from(p in "ai_providers"), :count) do
+      0 ->
+        attrs = %{
+          name: System.get_env("DEFAULT_PROVIDER_NAME", "default_provider"),
+          model_name: System.get_env("DEFAULT_MODEL_NAME", "gpt-4"),
+          api_token: System.get_env("DEFAULT_API_TOKEN", ""),
+          completions_url:
+            System.get_env(
+              "DEFAULT_COMPLETIONS_URL",
+              "https://api.openai.com/v1/chat/completions"
+            )
+        }
+
+        create(attrs)
+
+      _ ->
+        :ok
+    end
+  end
+end

lib/elixir_ai/data/conversation.ex

@@ -3,20 +3,39 @@ defmodule ElixirAi.Conversation do
   alias ElixirAi.Repo
 
   def all_names do
-    Repo.all(from c in "conversations", select: c.name)
+    Repo.all(
+      from(c in "conversations",
+        left_join: p in "ai_providers",
+        on: c.ai_provider_id == p.id,
+        select: %{
+          name: c.name,
+          provider: %{
+            name: p.name,
+            model_name: p.model_name,
+            api_token: p.api_token,
+            completions_url: p.completions_url
+          }
+        }
+      )
+    )
   end
 
-  def create(name) do
-    case Repo.insert_all("conversations", [[name: name, inserted_at: now(), updated_at: now()]]) do
+  def create(name, ai_provider_id) do
+    case Repo.insert_all("conversations", [
+           [name: name, ai_provider_id: ai_provider_id, inserted_at: now(), updated_at: now()]
+         ]) do
       {1, _} -> :ok
       _ -> {:error, :db_error}
     end
   rescue
-    e in Ecto.ConstraintError -> if e.constraint == "conversations_name_index", do: {:error, :already_exists}, else: {:error, :db_error}
+    e in Ecto.ConstraintError ->
+      if e.constraint == "conversations_name_index",
+        do: {:error, :already_exists},
+        else: {:error, :db_error}
   end
 
   def find_id(name) do
-    case Repo.one(from c in "conversations", where: c.name == ^name, select: c.id) do
+    case Repo.one(from(c in "conversations", where: c.name == ^name, select: c.id)) do
       nil -> {:error, :not_found}
       id -> {:ok, id}
     end