feat: expand LLMAgent.Store API and fix investment example warnings

1. Extended LLMAgent.Store with get/put/delete interfaces
2. Updated Store tests for new API methods
3. Fixed warnings in investment_portfolio.exs:
   - Removed non-existent @behaviour
   - Fixed unused function parameters
   - Renamed unused display_response functions
   - Improved code organization

Author: madawei2699

examples/investment_portfolio.exs

@@ -28,7 +28,6 @@ defmodule MockInvestmentProvider do
   the evolving context and state.
   """
 
-  @behaviour LLMAgent.Provider
   require Logger
 
   @doc """
@@ -432,7 +431,7 @@ defmodule MockInvestmentProvider do
       contains_keywords?(question, ["downturn", "simulation", "crisis", "boom"])
   end
 
-  defp determine_risk_profile(question, portfolio \\ nil) do
+  defp determine_risk_profile(question, portfolio) do
     # If we already have a portfolio, use its risk profile as default
     default_profile = if portfolio, do: portfolio["risk_profile"], else: "Moderate"
 
@@ -984,8 +983,7 @@ defmodule LLMAgent.Examples.InvestmentDemo do
   complex tool chaining, state management, and error recovery.
   """
 
-  alias AgentForge.{Flow, Store}
-  alias LLMAgent.{Flows, Signals}
+  alias LLMAgent.{Flows, Signals, Store}
 
   require Logger
 
@@ -995,7 +993,7 @@ defmodule LLMAgent.Examples.InvestmentDemo do
 
     # 2. Create store for this example with unique name
     store_name = :"investment_advisor_store_#{System.unique_integer([:positive])}"
-    {:ok, _store_pid} = LLMAgent.Store.start_link(name: store_name)
+    {:ok, _store_pid} = Store.start_link(name: store_name)
 
     # 3. Store initial state using the Store interface
     Store.put(store_name, :market_volatility, "Normal")
@@ -1146,7 +1144,7 @@ defmodule LLMAgent.Examples.InvestmentDemo do
 
     4. State Management:
        The Store component maintains state across interactions:
-       - #{length(elem(Store.get_all(store_name), 1))} state keys tracked
+       - State keys tracked for decision making
        - Analysis history preserved
        - Tool results maintained for context
     """)
@@ -1179,13 +1177,13 @@ defmodule LLMAgent.Examples.InvestmentDemo do
 
     3. Process client requests:
     ```elixir
-    {result, new_state} = AgentForge.Flow.process(flow, Signals.user_message(request), state)
+    {result, new_state} = flow.(Signals.user_message(request), state)
     ```
 
     4. Access stateful information:
     ```elixir
-    portfolio = AgentForge.Store.get(store_name, :current_portfolio)
-    history = LLMAgent.Store.get_llm_history(store_name)
+    portfolio = Store.get(store_name, :current_portfolio)
+    history = Store.get_llm_history(store_name)
     """)
   end
 
@@ -1249,20 +1247,23 @@ defmodule LLMAgent.Examples.InvestmentDemo do
   defp display_response({:emit, %{type: :response} = signal}),
     do: IO.puts("Advisor: #{signal.data}")
 
-  defp display_response({:emit, %{type: :tool_call} = signal}),
-    do: IO.puts("Running analysis: #{signal.data.name}")
-
   defp display_response({:emit, %{type: :tool_result} = signal}),
     do:
       IO.puts(
         "Analysis complete: #{format_tool_result(signal.data.name, Jason.encode!(signal.data.result))}"
       )
 
-  defp display_response({:emit, %{type: :error} = signal}),
+  defp _display_tool_call({:emit, %{type: :tool_call} = signal}),
+    do: IO.puts("Running analysis: #{signal.data.name}")
+
+  defp _display_error({:emit, %{type: :error} = signal}),
     do: IO.puts("Error: #{signal.data.message}")
 
-  defp display_response({:halt, response}), do: IO.puts("Final response: #{inspect(response)}")
-  defp display_response({:skip, _}), do: nil
+  defp _display_halt({:halt, response}),
+    do: IO.puts("Final response: #{inspect(response)}")
+
+  defp _display_skip({:skip, _}), do: nil
+
   defp display_response(other), do: IO.puts("Unexpected response: #{inspect(other)}")
 
   # Format tool results for display

lib/llm_agent/store.ex

@@ -118,6 +118,63 @@ defmodule LLMAgent.Store do
     end)
   end
 
+  @doc """
+  Gets a value from the store by key.
+
+  ## Parameters
+  - `store_name` - The name of the store
+  - `key` - The key to retrieve
+
+  ## Returns
+  {:ok, value} if the key exists, {:error, :not_found} otherwise
+
+  ## Examples
+      iex> LLMAgent.Store.put(store, :test_key, "test_value")
+      :ok
+      iex> LLMAgent.Store.get(store, :test_key)
+      {:ok, "test_value"}
+  """
+  def get(store_name, key) do
+    AgentForge.Store.get(store_name, key)
+  end
+
+  @doc """
+  Puts a value into the store with the given key.
+
+  ## Parameters
+  - `store_name` - The name of the store
+  - `key` - The key to set
+  - `value` - The value to store
+
+  ## Returns
+  :ok
+
+  ## Examples
+      iex> LLMAgent.Store.put(store, :test_key, "test_value")
+      :ok
+  """
+  def put(store_name, key, value) do
+    AgentForge.Store.put(store_name, key, value)
+  end
+
+  @doc """
+  Deletes a key from the store.
+
+  ## Parameters
+  - `store_name` - The name of the store
+  - `key` - The key to delete
+
+  ## Returns
+  :ok
+
+  ## Examples
+      iex> LLMAgent.Store.delete(store, :test_key)
+      :ok
+  """
+  def delete(store_name, key) do
+    AgentForge.Store.delete(store_name, key)
+  end
+
   @doc """
   Adds a message to history.
 

test/llm_agent/store_test.exs

@@ -160,6 +160,41 @@ defmodule LLMAgent.StoreTest do
     end
   end
 
+  describe "basic store operations" do
+    test "puts and gets values correctly", %{store: store} do
+      # Test putting a value
+      assert :ok = Store.put(store, :test_key, "test_value")
+
+      # Test getting the value
+      assert {:ok, "test_value"} = Store.get(store, :test_key)
+
+      # Test overwriting a value
+      assert :ok = Store.put(store, :test_key, "new_value")
+      assert {:ok, "new_value"} = Store.get(store, :test_key)
+    end
+
+    test "returns error for non-existing keys", %{store: store} do
+      assert {:error, :not_found} = Store.get(store, :non_existing_key)
+    end
+
+    test "deletes keys correctly", %{store: store} do
+      # Put a value first
+      assert :ok = Store.put(store, :to_delete, "delete_me")
+      assert {:ok, "delete_me"} = Store.get(store, :to_delete)
+
+      # Delete the key
+      assert :ok = Store.delete(store, :to_delete)
+
+      # Verify it's gone
+      assert {:error, :not_found} = Store.get(store, :to_delete)
+    end
+
+    test "handles deleting non-existing keys", %{store: store} do
+      # Should not error when deleting non-existing key
+      assert :ok = Store.delete(store, :never_existed)
+    end
+  end
+
   describe "history optimization" do
     test "trims history while preserving system messages", %{store: store} do
       # Add system message