Improve config layer

.envrc

@@ -1,4 +1,4 @@
-export VIRTUAL_ENV=."venv"
+export VIRTUAL_ENV="lambda"."venv"
 layout python
 
 [[ -f .envrc.private ]] && source_env .envrc.private

Makefile

@@ -16,6 +16,7 @@ clean:
 	rm -rf $(BUILD_PACKAGE_DIR)
 
 dev: clean
+	cd lambda
 	python -m venv .venv
 	. .venv/bin/activate
 	pip install -r lambda/requirements-dev.txt

lambda/lambda_function.py

@@ -29,27 +29,6 @@
 config = load_config()
 canned_response = CannedResponse("en-US")
 
-LLM_URL = config["llm_url"]
-LLM_KEY = config["llm_key"]
-LLM_MODEL = config["llm_model"]
-LLM_SYSTEM_PROMPT = config.get(
-    "llm_system_prompt",
-    """
-    You are a helpful AI assistant that responds by voice.
-    Your answers should be simple and quick.
-    Don't speak back for more than a couple of sentences.
-    If you need to say more things, say that you're happy to continue,
-    and wait for the user to ask you to continue.
-    Remember, your objective is to reply as if your are having a natural
-    conversation, so be relatively brief, and keep that in mind when replying.
-    You were created by jpt.land as part of a personal exploration project.
-    Paulo Truta is a software engineer that worked hard to make you easy!
-    If the user asks about you, tell him you are the Alexa AI Skill.
-    You're an helpful and funny artificial powered assistant,
-    ready to answer any questions a person may have, right on Amazon Alexa.
-""",
-)
-
 
 class LLMQuestionProxy:
     """Handler to communicate with an LLM via API or Webhook.
@@ -65,7 +44,7 @@ def api_request(self, question: str) -> dict:
         )
 
         try:
-            response = self.llm_client.api_request(LLM_SYSTEM_PROMPT, question)
+            response = self.llm_client.api_request(config.llm_system_prompt, question)
 
             logger.info(response)
 
@@ -93,18 +72,20 @@ def webhook_request(self, question: str, context: dict) -> dict:
 
     def ask(self, question: str, context: dict = {}) -> dict:
         """Ask a question and get a response."""
-        if LLM_MODEL != "webhook":
-            logger.info("Using API request")
-            return self.api_request(question)
-        else:
+        if config.llm_model == "webhook":
             logger.info("Using Webhook request")
             return self.webhook_request(question, context)
+        else:
+            logger.info("Using API request")
+            return self.api_request(question)
 
 
 class BaseRequestHandler(AbstractRequestHandler):
     """Base class for request handlers."""
 
-    question = LLMQuestionProxy(LLMClient(LLM_URL, LLM_KEY, LLM_MODEL))
+    question = LLMQuestionProxy(
+        LLMClient(config.llm_url, config.llm_key, config.llm_model)
+    )
 
     def can_handle(self, handler_input: HandlerInput) -> bool:
         return True

lambda/llm_intent/utils.py

@@ -2,15 +2,39 @@
 import random
 from os.path import exists
 
-CONFIG_FILE = "config.json"
+from pydantic import BaseModel
 
+CONFIG_FILE = "config.json"
 
-def load_config() -> dict:
+DEFAULT_PROMPT = """
+    You are a helpful AI assistant that responds by voice.
+    Your answers should be simple and quick.
+    Don't speak back for more than a couple of sentences.
+    If you need to say more things, say that you're happy to continue,
+    and wait for the user to ask you to continue.
+    Remember, your objective is to reply as if your are having a natural
+    conversation, so be relatively brief, and keep that in mind when replying.
+    You were created by jpt.land as part of a personal exploration project.
+    Paulo Truta is a software engineer that worked hard to make you easy!
+    If the user asks about you, tell him you are the Alexa AI Skill.
+    You're an helpful and funny artificial powered assistant,
+    ready to answer any questions a person may have, right on Amazon Alexa.
+"""
+
+
+class Config(BaseModel):
+    llm_url: str
+    llm_key: str
+    llm_model: str
+    llm_system_prompt: str = DEFAULT_PROMPT
+
+
+def load_config() -> Config:
     if not exists(CONFIG_FILE):
         raise ValueError("Config file does not exist")
 
     with open(CONFIG_FILE) as f:
-        return json.load(f)
+        return Config.model_validate(json.load(f))
 
 
 class CannedResponse:

lambda/requirements.txt

@@ -1,2 +1,3 @@
 urllib3==1.26.15
 ask-sdk-core==1.19.0
+pydantic==2.10.5

lambda/tests/test_utils.py

@@ -1,17 +1,62 @@
+import json
 from unittest import TestCase
 from unittest.mock import mock_open, patch
 
-from llm_intent.utils import CONFIG_FILE, CannedResponse, load_config
+from llm_intent.utils import CONFIG_FILE, DEFAULT_PROMPT, CannedResponse, load_config
+from pydantic import ValidationError
 
 
 class TestLoadConfig(TestCase):
-    @patch("builtins.open", new_callable=mock_open, read_data='{"key": "value"}')
+    MINIMUM_CONFIG = {
+        "llm_url": "http://example.org",
+        "llm_key": "llm_key",
+        "llm_model": "llm_model",
+    }
+
+    COMPLETE_CONFIG = {
+        "llm_url": "http://example.org",
+        "llm_key": "llm_key",
+        "llm_model": "llm_model",
+        "llm_system_prompt": "llm_prompt",
+    }
+
+    @patch(
+        "builtins.open", new_callable=mock_open, read_data=json.dumps(COMPLETE_CONFIG)
+    )
     @patch("llm_intent.utils.exists", return_value=True)
     def test_load_config_success(self, mock_exists, mock_open_file):
         """Test loading configuration successfully."""
-        expected_config = {"key": "value"}
         config = load_config()
-        self.assertEqual(config, expected_config)
+        self.assertEqual(config.llm_url, TestLoadConfig.COMPLETE_CONFIG["llm_url"])
+        self.assertEqual(config.llm_key, TestLoadConfig.COMPLETE_CONFIG["llm_key"])
+        self.assertEqual(config.llm_model, TestLoadConfig.COMPLETE_CONFIG["llm_model"])
+        self.assertEqual(
+            config.llm_system_prompt,
+            TestLoadConfig.COMPLETE_CONFIG["llm_system_prompt"],
+        )
+        mock_exists.assert_called_once_with(CONFIG_FILE)
+        mock_open_file.assert_called_once_with(CONFIG_FILE)
+
+    @patch(
+        "builtins.open", new_callable=mock_open, read_data=json.dumps(MINIMUM_CONFIG)
+    )
+    @patch("llm_intent.utils.exists", return_value=True)
+    def test_load_config_default_prompt(self, mock_exists, mock_open_file):
+        """Test loading configuration with default successfully."""
+        config = load_config()
+        self.assertEqual(config.llm_url, TestLoadConfig.COMPLETE_CONFIG["llm_url"])
+        self.assertEqual(config.llm_key, TestLoadConfig.COMPLETE_CONFIG["llm_key"])
+        self.assertEqual(config.llm_model, TestLoadConfig.COMPLETE_CONFIG["llm_model"])
+        self.assertEqual(config.llm_system_prompt, DEFAULT_PROMPT)
+        mock_exists.assert_called_once_with(CONFIG_FILE)
+        mock_open_file.assert_called_once_with(CONFIG_FILE)
+
+    @patch("builtins.open", new_callable=mock_open, read_data=json.dumps({}))
+    @patch("llm_intent.utils.exists", return_value=True)
+    def test_load_config_missing_fields(self, mock_exists, mock_open_file):
+        """Test loading configuration missing fields."""
+        with self.assertRaises(ValidationError):
+            load_config()
         mock_exists.assert_called_once_with(CONFIG_FILE)
         mock_open_file.assert_called_once_with(CONFIG_FILE)