Add oauth to authentication flow to client creation

Author: zacksiri

lib/tama_ex.ex

@@ -4,17 +4,87 @@ defmodule TamaEx do
   """
 
   @doc """
-  Creates a new HTTP client with the given base URL.
+  Creates a new HTTP client with authentication.
+
+  This function performs OAuth2 client credentials authentication and returns
+  an authenticated HTTP client. The base_url should be the root URL of the API server.
+
+  ## Parameters
+    - base_url - The root base URL for the API server (e.g., "https://api.example.com")
+    - client_id - The OAuth2 client ID
+    - client_secret - The OAuth2 client secret
+    - options - Optional configuration (e.g., scopes)
+
+  ## Returns
+    - `{:ok, %{client: client, expires_in: seconds}}` on successful authentication
+    - `{:error, reason}` on authentication failure
+
+  ## Examples
+
+      # Create client with root URL
+      {:ok, %{client: client}} = TamaEx.client("https://api.example.com", "client_id", "client_secret")
+
+      # Add namespace for specific operations
+      namespaced_client = TamaEx.put_namespace(client, "provision")
+
+  """
+  def client(
+        base_url,
+        client_id,
+        client_secret,
+        options \\ []
+      ) do
+    scopes = Keyword.get(options, :scopes) || ["provision.all"]
+
+    token = Base.url_encode64("#{client_id}:#{client_secret}", padding: false)
+
+    body = %{
+      "grant_type" => "client_credentials",
+      "scope" => Enum.join(scopes, " ")
+    }
+
+    case Req.new(
+           base_url: base_url,
+           headers: [{"authorization", "Bearer #{token}"}]
+         )
+         |> Req.post(url: "/auth/tokens", json: body) do
+      {:ok, %Req.Response{status: 200, body: token}} ->
+        headers = [{"authorization", "Bearer #{token["access_token"]}"}]
+
+        {:ok,
+         %{client: Req.new(base_url: base_url, headers: headers), expires_in: token["expires_in"]}}
+
+      {:ok, %Req.Response{body: body}} ->
+        {:error, body}
+
+      {:error, reason} ->
+        {:error, reason}
+    end
+  end
+
+  @doc """
+  Adds a namespace to the client's base URL.
+
+  ## Parameters
+    - client - The HTTP client
+    - namespace - The namespace to append (e.g., "provision", "ingest")
+
+  ## Returns
+    - Updated client with namespaced base URL
 
   ## Examples
 
-      iex> client = TamaEx.client(base_url: "https://api.example.com")
-      iex> client.options[:base_url]
-      "https://api.example.com"
+      iex> client = Req.new(base_url: "https://api.example.com")
+      iex> namespaced_client = TamaEx.put_namespace(client, "provision")
+      iex> namespaced_client.options[:base_url]
+      "https://api.example.com/provision"
 
   """
-  def client(base_url: base_url) do
-    Req.new(base_url: base_url)
+  def put_namespace(%Req.Request{} = client, namespace) when is_binary(namespace) do
+    current_base_url = client.options[:base_url] || ""
+    new_base_url = "#{current_base_url}/#{namespace}"
+
+    Req.merge(client, base_url: new_base_url)
   end
 
   @doc """
@@ -70,12 +140,12 @@ defmodule TamaEx do
 
   ## Examples
 
-      iex> client = TamaEx.client(base_url: "https://api.example.com/provision")
+      iex> client = %Req.Request{options: %{base_url: "https://api.example.com/provision"}}
       iex> {:ok, validated_client} = TamaEx.validate_client(client, ["provision"])
       iex> validated_client == client
       true
 
-      iex> client = TamaEx.client(base_url: "https://api.example.com/ingest")
+      iex> client = %Req.Request{options: %{base_url: "https://api.example.com/ingest"}}
       iex> try do
       ...>   TamaEx.validate_client(client, ["provision"])
       ...> rescue

lib/tama_ex/perception.ex

@@ -15,7 +15,7 @@ defmodule TamaEx.Perception do
 
   ## Examples
 
-      iex> client = TamaEx.client(base_url: "https://api.example.com/provision")
+      iex> client = %Req.Request{options: %{base_url: "https://api.example.com/provision"}}
       iex> {:ok, _} = TamaEx.validate_client(client, ["provision"])
       iex> is_binary("space_123") and is_binary("my-chain")
       true

test/tama_ex/agentic_test.exs

@@ -1,20 +1,19 @@
 defmodule TamaEx.AgenticTest do
   use ExUnit.Case
+  import TestHelpers
   doctest TamaEx.Agentic
 
   alias TamaEx.Agentic
 
   setup do
     bypass = Bypass.open()
-    client = TamaEx.client(base_url: "http://localhost:#{bypass.port}/agentic")
-
-    {:ok, bypass: bypass, client: client}
+    {:ok, bypass: bypass}
   end
 
   describe "create_message/3 - client validation" do
-    test "validates required client namespace", %{client: _client} do
+    test "validates required client namespace" do
       # Test with wrong namespace
-      client = TamaEx.client(base_url: "https://api.example.com/provision")
+      client = mock_client("provision")
 
       body = %{
         "recipient" => "user-123",
@@ -51,7 +50,8 @@ defmodule TamaEx.AgenticTest do
   end
 
   describe "create_message/3 - message validation" do
-    test "handles invalid message params", %{client: client} do
+    test "handles invalid message params" do
+      client = mock_client("agentic")
       # Test with missing required fields
       invalid_body = %{
         "content" => "Hello, world!"
@@ -63,7 +63,9 @@ defmodule TamaEx.AgenticTest do
       end
     end
 
-    test "validates message structure with missing author", %{client: client} do
+    test "validates message structure with missing author" do
+      client = mock_client("agentic")
+
       invalid_body = %{
         "recipient" => "user-123",
         "content" => "Hello, world!",
@@ -79,7 +81,10 @@ defmodule TamaEx.AgenticTest do
   end
 
   describe "create_message/3 - non-streaming requests" do
-    test "handles successful non-streaming response", %{bypass: bypass, client: client} do
+    test "handles successful non-streaming response", %{bypass: bypass} do
+      base_url = "http://localhost:#{bypass.port}"
+      client = mock_client("agentic", base_url)
+
       Bypass.expect(bypass, "POST", "/agentic/messages", fn conn ->
         {:ok, body, conn} = Plug.Conn.read_body(conn)
         request_data = Jason.decode!(body)
@@ -138,7 +143,10 @@ defmodule TamaEx.AgenticTest do
       assert response_body["message"]["content"] == "Hello, world!"
     end
 
-    test "handles non-streaming request with custom options", %{bypass: bypass, client: client} do
+    test "handles non-streaming request with custom options", %{bypass: bypass} do
+      base_url = "http://localhost:#{bypass.port}"
+      client = mock_client("agentic", base_url)
+
       Bypass.expect(bypass, "POST", "/agentic/messages", fn conn ->
         # Check headers
         assert Plug.Conn.get_req_header(conn, "authorization") == ["Bearer test-token"]
@@ -194,7 +202,9 @@ defmodule TamaEx.AgenticTest do
   end
 
   describe "create_message/3 - streaming requests" do
-    test "raises error when stream is true but no callback provided", %{client: client} do
+    test "raises error when stream is true but no callback provided" do
+      client = mock_client("agentic")
+
       body = %{
         "recipient" => "user-123",
         "content" => "Hello, streaming world!",
@@ -228,7 +238,9 @@ defmodule TamaEx.AgenticTest do
       end
     end
 
-    test "handles streaming response with callback", %{bypass: bypass, client: client} do
+    test "handles streaming response with callback", %{bypass: bypass} do
+      base_url = "http://localhost:#{bypass.port}"
+      client = mock_client("agentic", base_url)
       test_pid = self()
 
       Bypass.expect(bypass, "POST", "/agentic/messages", fn conn ->
@@ -336,7 +348,9 @@ defmodule TamaEx.AgenticTest do
       assert final_chunk["message"]["final_content"] == "Hello streaming world!"
     end
 
-    test "handles streaming with atom keys in body", %{bypass: bypass, client: client} do
+    test "handles streaming with atom keys in body", %{bypass: bypass} do
+      base_url = "http://localhost:#{bypass.port}"
+      client = mock_client("agentic", base_url)
       test_pid = self()
 
       Bypass.expect(bypass, "POST", "/agentic/messages", fn conn ->
@@ -395,7 +409,9 @@ defmodule TamaEx.AgenticTest do
   end
 
   describe "data parsing functionality" do
-    test "handles mixed streaming data formats", %{bypass: bypass, client: client} do
+    test "handles mixed streaming data formats", %{bypass: bypass} do
+      base_url = "http://localhost:#{bypass.port}"
+      client = mock_client("agentic", base_url)
       test_pid = self()
 
       Bypass.expect(bypass, "POST", "/agentic/messages", fn conn ->
@@ -449,7 +465,9 @@ defmodule TamaEx.AgenticTest do
   end
 
   describe "timeout handling" do
-    test "uses default timeout when not specified", %{bypass: bypass, client: client} do
+    test "uses default timeout when not specified", %{bypass: bypass} do
+      base_url = "http://localhost:#{bypass.port}"
+      client = mock_client("agentic", base_url)
       # We can't directly test the timeout value, but we can verify the request is made
       Bypass.expect(bypass, "POST", "/agentic/messages", fn conn ->
         # Simulate a request that would benefit from long timeout
@@ -486,7 +504,10 @@ defmodule TamaEx.AgenticTest do
       assert response_body["id"] == "timeout-test-123"
     end
 
-    test "uses custom timeout when specified", %{bypass: bypass, client: client} do
+    test "uses custom timeout when specified", %{bypass: bypass} do
+      base_url = "http://localhost:#{bypass.port}"
+      client = mock_client("agentic", base_url)
+
       Bypass.expect(bypass, "POST", "/agentic/messages", fn conn ->
         response_data = %{
           id: "custom-timeout-456",

test/tama_ex/memory_test.exs

@@ -1,5 +1,6 @@
 defmodule TamaEx.MemoryTest do
   use ExUnit.Case
+  import TestHelpers
   doctest TamaEx.Memory
 
   alias TamaEx.Memory
@@ -16,11 +17,6 @@ defmodule TamaEx.MemoryTest do
     }
   end
 
-  # Test helper for creating a mock client
-  defp mock_client(namespace) do
-    TamaEx.client(base_url: "https://api.example.com/#{namespace}")
-  end
-
   describe "create_entity/3" do
     test "creates entity with valid parameters" do
       _client = mock_client("ingest")

test/tama_ex/neural_test.exs

@@ -1,5 +1,6 @@
 defmodule TamaEx.NeuralTest do
   use ExUnit.Case
+  import TestHelpers
   # Disable doctests due to undefined client variable in examples
   # doctest TamaEx.Neural
 
@@ -29,11 +30,6 @@ defmodule TamaEx.NeuralTest do
     }
   end
 
-  # Test helper for creating a mock client
-  defp mock_client(namespace) do
-    TamaEx.client(base_url: "https://api.example.com/#{namespace}")
-  end
-
   describe "get_space/2" do
     test "validates required client namespace" do
       # Test with wrong namespace

test/tama_ex/perception_test.exs

@@ -1,5 +1,6 @@
 defmodule TamaEx.PerceptionTest do
   use ExUnit.Case
+  import TestHelpers
   doctest TamaEx.Perception
 
   alias TamaEx.Perception
@@ -18,14 +19,13 @@ defmodule TamaEx.PerceptionTest do
     }
   end
 
-  # Test helper for creating a mock client
-  defp mock_client(namespace) do
-    TamaEx.client(base_url: "https://api.example.com/#{namespace}")
-  end
-
   setup do
-    bypass = Bypass.open()
-    client = TamaEx.client(base_url: "http://localhost:#{bypass.port}/perception")
+    {bypass, base_url} = setup_bypass_with_auth()
+
+    {:ok, %{client: base_client}} =
+      TamaEx.client(base_url, "test_client", "test_secret")
+
+    client = TamaEx.put_namespace(base_client, "perception")
 
     {:ok, bypass: bypass, client: client}
   end
@@ -266,7 +266,7 @@ defmodule TamaEx.PerceptionTest do
 
   describe "list_concepts/3" do
     test "validates required client namespace", %{bypass: bypass} do
-      client = TamaEx.client(base_url: "http://localhost:#{bypass.port}/ingest")
+      client = mock_client("ingest", "http://localhost:#{bypass.port}")
       entity_id = "entity_123"
 
       assert_raise ArgumentError, ~r/Invalid client namespace/, fn ->
@@ -444,7 +444,7 @@ defmodule TamaEx.PerceptionTest do
 
     test "handles network errors" do
       # Use an invalid port to simulate network error
-      invalid_client = TamaEx.client(base_url: "http://localhost:99999/perception")
+      invalid_client = mock_client("perception", "http://localhost:99999")
 
       # The connection error may be raised as an exception instead of returning error tuple
       result =