{llamacpp_models_html}
@@ -3353,7 +3777,7 @@ async def get_dashboard():
-
{src_badge('GOOSE', '#fbbf24')} Session Directory
+
{src_badge("GOOSE", "#fbbf24")} Session Directory
{goose_html}
@@ -3365,21 +3789,21 @@ async def get_dashboard():
@@ -3395,6 +3819,7 @@ async def get_dashboard():
"""
return html_content
+
# --- Static files (visualizer, data files) ---
STATIC_DIR = Path(__file__).resolve().parent / "static"
DATA_DIR = Path(__file__).resolve().parent / "data"
@@ -3402,6 +3827,7 @@ async def get_dashboard():
app.mount("/static", StaticFiles(directory=str(STATIC_DIR)), name="static")
app.mount("/data", StaticFiles(directory=str(DATA_DIR)), name="data")
+
@app.get("/visualizer", response_class=HTMLResponse)
async def get_visualizer():
"""Serve the dataset visualizer for human review."""
@@ -3412,106 +3838,101 @@ async def get_visualizer():
return HTMLResponse("
Visualizer not found
", status_code=404)
+VALID_TIERS = {"agent-simple-core", "agent-medium-core", "agent-complex-core", "agent-reasoning-core", "agent-advanced-core"}
+MAX_ANNOTATION_KEY_LENGTH = 128
+MAX_ANNOTATION_ITEM_BYTES = 4096
+
class AnnotationItem(BaseModel):
"""Pydantic model representing a single human dataset review annotation."""
- tier: Union[int, str, None] = None
- note: str = ""
- ts: Optional[str] = None
+ model_config = ConfigDict(extra="forbid")
-VALID_TIERS = {"agent-simple-core", "agent-medium-core", "agent-complex-core", "agent-reasoning-core", "agent-advanced-core"}
+ tier: Union[int, str, None] = None
+ note: Optional[str] = Field(default=None, max_length=1000)
+ ts: Optional[str] = Field(default=None, max_length=100)
+
+ @field_validator("tier")
+ @classmethod
+ def validate_tier(cls, v):
+ if v is None:
+ return v
+ if isinstance(v, int):
+ if v < 0 or v > 4:
+ raise ValueError(f"Invalid tier index {v}: must be between 0 and 4")
+ elif isinstance(v, str):
+ if v not in VALID_TIERS and v != "?":
+ raise ValueError(f"Invalid tier string '{v}'")
+ else:
+ raise ValueError("Tier must be int, str, or null")
+ return v
+
+class AnnotationPayload(RootModel):
+ root: Dict[str, AnnotationItem]
+
+ @model_validator(mode="after")
+ def validate_payload(self) -> "AnnotationPayload":
+ data = self.root
+ if len(data) > 1000:
+ raise ValueError("Payload size limit exceeded: maximum of 1000 annotations allowed per request.")
+ for k, item in data.items():
+ if len(k) > MAX_ANNOTATION_KEY_LENGTH:
+ raise ValueError(f"Invalid payload key '{k}': key is too long.")
+ is_valid_key = k.isdigit() or (
+ k.startswith("h") and len(k) > 1 and all(c in "0123456789abcdef" for c in k[1:].lower())
+ )
+ if not is_valid_key:
+ raise ValueError(f"Invalid payload key '{k}': keys must be numeric strings or stable hash keys (e.g., 'h12345abc').")
+ if len(item.model_dump_json().encode("utf-8")) > MAX_ANNOTATION_ITEM_BYTES:
+ raise ValueError(f"Annotation '{k}' exceeds the maximum serialized size.")
+ return self
# NOTE: annotations_lock (asyncio.Lock) only provides concurrency protection within
# a single Python process. In multi-worker uvicorn deployments, concurrent requests
# across different workers can still race. Eventual consistency is maintained via
# the atomic file-replace mechanism, which is acceptable for this dashboard feature.
annotations_lock = asyncio.Lock()
-_annotations_cache = {}
-
-async def _read_annotations_async(path) -> dict:
- import copy
-
- # Do not swallow OSError if file doesn't exist to preserve original behavior.
- # The caller (save_annotations) handles the exception when reading existing annotations.
- current_mtime = await asyncio.to_thread(os.path.getmtime, path)
-
- cache_entry = _annotations_cache.get(path)
- if cache_entry is None or current_mtime != cache_entry["mtime"]:
- async with aiofiles.open(path, "r", encoding="utf-8") as f:
- # Read asynchronously, but parse in a thread pool to avoid blocking event loop
- content = await f.read()
- data = await asyncio.to_thread(json.loads, content)
- _annotations_cache[path] = {"mtime": current_mtime, "data": data}
+def _read_annotations_sync(path) -> dict:
+ with open(path, "r", encoding="utf-8") as f:
+ return json.load(f)
- return await asyncio.to_thread(copy.deepcopy, _annotations_cache[path]["data"])
@app.post("/dashboard/save-annotations")
-async def save_annotations(payload: Dict[str, AnnotationItem]):
+async def save_annotations(payload: AnnotationPayload):
"""Save human review annotations to disk."""
- if len(payload) > 1000:
- raise HTTPException(
- status_code=400,
- detail="Payload size limit exceeded: maximum of 1000 annotations allowed per request."
- )
- for k, item in payload.items():
- # Allow numeric strings (dataset indexes) or stable hash keys starting with 'h' (hexadecimal)
- is_valid_key = k.isdigit() or (
- k.startswith("h") and len(k) > 1 and all(c in "0123456789abcdef" for c in k[1:].lower())
- )
- if not is_valid_key:
- raise HTTPException(
- status_code=400,
- detail=f"Invalid payload key '{k}': keys must be numeric strings or stable hash keys (e.g., 'h12345abc')."
- )
-
- t = item.tier
- if t is not None:
- if isinstance(t, int):
- if t < 0 or t > 4:
- raise HTTPException(
- status_code=400,
- detail=f"Invalid tier index {t} for index {k}: must be between 0 and 4."
- )
- elif isinstance(t, str):
- if t not in VALID_TIERS and t != "?":
- raise HTTPException(
- status_code=400,
- detail=f"Invalid tier string '{t}' for index {k}."
- )
- else:
- raise HTTPException(
- status_code=400,
- detail=f"Invalid tier type for index {k}: must be int, str, or null."
- )
-
- if item.note and len(item.note) > 1000:
- raise HTTPException(
- status_code=400,
- detail=f"Note length limit exceeded at index {k}: maximum of 1000 characters allowed."
- )
try:
+ data = payload.root
ann_path = DATA_DIR / "annotations.json"
existing = {}
async with annotations_lock:
if ann_path.exists():
try:
- existing = await _read_annotations_async(str(ann_path))
+ existing = await asyncio.to_thread(
+ _read_annotations_sync, str(ann_path)
+ )
except Exception as read_err:
- logger.warning(f"Could not read existing annotations: {read_err}. Overwriting.")
+ logger.warning(
+ f"Could not read existing annotations: {read_err}. Overwriting."
+ )
# Merge new annotations into existing
- for k, item in payload.items():
- existing[k] = item.model_dump() if hasattr(item, "model_dump") else item.dict()
-
+ for k, item in data.items():
+ # For partial updates, merge only fields provided in the request
+ update_data = item.model_dump(exclude_unset=True)
+ if k in existing and isinstance(existing[k], dict):
+ existing[k].update(update_data)
+ else:
+ existing[k] = item.model_dump()
await _atomic_write_json_async(str(ann_path), existing)
- return JSONResponse({"status": "ok", "saved": len(payload)})
+ return JSONResponse({"status": "ok", "saved": len(data)})
except Exception as e:
logger.error(f"Failed to save annotations: {e}")
raise HTTPException(status_code=500, detail="Failed to save annotations")
+
if __name__ == "__main__":
import uvicorn
+
logger.info(f"Starting LLM Triage Router on {host}:{port}...")
uvicorn.run(app, host=host, port=port)
diff --git a/router/memory_mcp.py b/router/memory_mcp.py
index 7ec87c26..f2187282 100755
--- a/router/memory_mcp.py
+++ b/router/memory_mcp.py
@@ -17,7 +17,6 @@
import time
import hashlib
import httpx
-import urllib.parse
API_URL = "http://127.0.0.1:5000/v1/memory"
PROTOCOL_VERSION = "2024-11-05"
@@ -45,8 +44,7 @@ def _make_key(category: str, is_global: bool, data: str) -> str:
# BLAKE2b: SOTA crypto hash, stdlib, faster than MD5, deterministic across restarts.
# Provides uniqueness within the same millisecond.
h = hashlib.blake2b((data + str(ts)).encode("utf-8"), digest_size=HASH_DIGEST_SIZE).hexdigest()
- safe_category = urllib.parse.quote(category)
- return f"{PREFIX}:{scope}:{safe_category}::{ts}:{h}"
+ return f"{PREFIX}:{scope}:{category}::{ts}:{h}"
def _parse_key(key: str):
@@ -55,7 +53,7 @@ def _parse_key(key: str):
parts = key.split("::")
prefix = parts[0].split(":") # memory:{scope}:{category}
scope = prefix[1] if len(prefix) > 1 else ""
- category = urllib.parse.unquote(prefix[2]) if len(prefix) > 2 else ""
+ category = prefix[2] if len(prefix) > 2 else ""
ts_hash = parts[1] if len(parts) > 1 else ""
ts = ts_hash.split(":")[0] if ts_hash else ""
return {"scope": scope, "category": category, "timestamp": ts}
@@ -70,8 +68,6 @@ def _parse_key(key: str):
def _is_memory_key(key: str) -> bool:
"""Check if a key follows the memory:{scope}:{category}:: format."""
- if not isinstance(key, str):
- return False
return key.startswith(f"{PREFIX}:")
diff --git a/router/test_memory_mcp.py b/router/test_memory_mcp.py
index 7572c0c7..24d23a34 100644
--- a/router/test_memory_mcp.py
+++ b/router/test_memory_mcp.py
@@ -4,7 +4,7 @@
import json
from pathlib import Path
sys.path.insert(0, str(Path(__file__).resolve().parent))
-from memory_mcp import _is_memory_key, _make_key, SCOPE_GLOBAL, SCOPE_LOCAL, PREFIX, _memory_value, _parse_memory_value
+from memory_mcp import _make_key, SCOPE_GLOBAL, SCOPE_LOCAL, PREFIX, _memory_value, _parse_memory_value
def test_make_key_global():
"""Test generating a key for global scope."""
@@ -129,37 +129,3 @@ def test_parse_memory_value_invalid_json_string():
"""Test _parse_memory_value with invalid JSON string."""
result = _parse_memory_value("this is not a valid json string")
assert result == {"data": "this is not a valid json string", "tags": []}
-
-def test_make_key_category_with_colons():
- """Test generating and parsing a key when the category contains colons."""
- from router.memory_mcp import _parse_key
- category = "test:category::with:colons"
- data = "test_data"
-
- key = _make_key(category, True, data)
-
- # Check that it encoded the colons safely
- assert "%3A" in key
- assert "test:category" not in key
-
- # Check that it parses back successfully
- parsed = _parse_key(key)
- assert parsed["category"] == category
- assert parsed["scope"] == SCOPE_GLOBAL
-
-
-def test_is_memory_key_true():
- """Test _is_memory_key with a valid memory key prefix."""
- assert _is_memory_key(f"{PREFIX}:global:test_cat::123:abc") is True
-
-def test_is_memory_key_false_wrong_prefix():
- """Test _is_memory_key with an incorrect prefix."""
- assert _is_memory_key("not_memory:global:test_cat::123:abc") is False
-
-def test_is_memory_key_empty():
- """Test _is_memory_key with an empty string."""
- assert _is_memory_key("") is False
-
-def test_is_memory_key_none_or_non_string():
- """Test _is_memory_key with None or non-string inputs."""
- assert _is_memory_key(None) is False
diff --git a/router/tests/test_detect_active_tool.py b/router/tests/test_detect_active_tool.py
deleted file mode 100644
index 3105ab1e..00000000
--- a/router/tests/test_detect_active_tool.py
+++ /dev/null
@@ -1,114 +0,0 @@
-import pytest
-import os
-import sys
-from pathlib import Path
-
-# Set CONFIG_PATH for import
-os.environ["CONFIG_PATH"] = str(Path(__file__).resolve().parent.parent / "config.yaml")
-
-# Add the parent directory to the path so we can import from router
-sys.path.insert(0, str(Path(__file__).resolve().parent.parent))
-
-from router.main import detect_active_tool
-
-def test_detect_active_tool_empty():
- assert detect_active_tool({}) == "none"
- assert detect_active_tool({"messages": []}) == "none"
- assert detect_active_tool({"messages": [{"role": "system", "content": "hello"}]}) == "none"
-
-def test_detect_active_tool_role_tool_with_name():
- # Write tool name mapped to write
- body = {
- "messages": [
- {"role": "tool", "name": "edit_file", "content": "..."}
- ]
- }
- assert detect_active_tool(body) == "write"
-
- # View tool mapped to view
- body = {
- "messages": [
- {"role": "tool", "name": "cat_file", "content": "..."}
- ]
- }
- assert detect_active_tool(body) == "view"
-
-def test_detect_active_tool_role_tool_without_name_but_matched_tool_call_id():
- body = {
- "messages": [
- {"role": "assistant", "tool_calls": [{"id": "call_123", "function": {"name": "read_file"}}]},
- {"role": "tool", "tool_call_id": "call_123", "content": "success"}
- ]
- }
- assert detect_active_tool(body) == "view"
-
-def test_detect_active_tool_role_tool_without_name_unmatched_tool_call_id():
- body = {
- "messages": [
- {"role": "assistant", "tool_calls": [{"id": "call_999", "function": {"name": "read_file"}}]},
- {"role": "tool", "tool_call_id": "call_123", "content": "success"}
- ]
- }
- assert detect_active_tool(body) == "other"
-
-def test_detect_active_tool_role_assistant_with_tool_calls():
- body = {
- "messages": [
- {"role": "user", "content": "do something"},
- {"role": "assistant", "tool_calls": [{"id": "call_1", "function": {"name": "write_to_file"}}]}
- ]
- }
- assert detect_active_tool(body) == "write"
-
-def test_detect_active_tool_fallback_user_keyword():
- # Tests matching "tree"
- body = {
- "messages": [
- {"role": "user", "content": "show me the tree"}
- ]
- }
- assert detect_active_tool(body) == "tree"
-
- # Tests matching "shell"
- body = {
- "messages": [
- {"role": "user", "content": "run this in shell"}
- ]
- }
- assert detect_active_tool(body) == "shell"
-
- # Tests matching "write"
- body = {
- "messages": [
- {"role": "user", "content": "create file test.py"}
- ]
- }
- assert detect_active_tool(body) == "write"
-
- # Tests matching "view"
- body = {
- "messages": [
- {"role": "user", "content": "cat main.py"}
- ]
- }
- assert detect_active_tool(body) == "view"
-
-def test_detect_active_tool_ignores_invalid_message_formats():
- body = {
- "messages": [
- "this is not a dict",
- {"role": "user", "content": "read this"}
- ]
- }
- assert detect_active_tool(body) == "view"
-
-def test_detect_active_tool_precedence():
- # If there are multiple tools, it processes from the last message backwards
- body = {
- "messages": [
- {"role": "tool", "name": "edit_file", "content": "done"},
- {"role": "tool", "name": "cat_file", "content": "..."}
- ]
- }
- # It starts from the end, so it sees "cat_file" first, which maps to "view"
- assert detect_active_tool(body) == "view"
diff --git a/router/tests/test_estimate_prompt_tokens.py b/router/tests/test_estimate_prompt_tokens.py
index ae74a9e5..e93390f9 100644
--- a/router/tests/test_estimate_prompt_tokens.py
+++ b/router/tests/test_estimate_prompt_tokens.py
@@ -23,27 +23,25 @@ def test_estimate_prompt_tokens_empty_messages():
def test_estimate_prompt_tokens_string_content():
body = {
"messages": [
- {"content": "word " * 4}, # 4 * 1.2 = 4.8
- {"content": "word " * 8} # 8 * 1.2 = 9.6
+ {"content": "1234"}, # 1 token
+ {"content": "12345678"} # 2 tokens
]
}
- # Total is int(round(4.8 + 9.6)) + 50 = int(round(14.4)) + 50 = 14 + 50 = 64
- assert estimate_prompt_tokens(body) == 50 + 14
+ assert estimate_prompt_tokens(body) == 50 + 1 + 2
def test_estimate_prompt_tokens_list_content():
body = {
"messages": [
{
"content": [
- {"type": "text", "text": "word " * 4}, # 4.8 tokens
+ {"type": "text", "text": "1234"}, # 1 token
{"type": "image_url", "url": "ignored"}, # 0 tokens
- {"type": "text", "text": "word " * 8} # 9.6 tokens
+ {"type": "text", "text": "12345678"} # 2 tokens
]
}
]
}
- # Total is int(round(4.8 + 9.6)) + 50 = 64
- assert estimate_prompt_tokens(body) == 50 + 14
+ assert estimate_prompt_tokens(body) == 50 + 1 + 2
def test_estimate_prompt_tokens_mixed_and_invalid_msgs():
body = {
@@ -54,11 +52,10 @@ def test_estimate_prompt_tokens_mixed_and_invalid_msgs():
"invalid_block_type", # Should be skipped
{"type": "text", "text": None} # None text, handled as empty string
]},
- {"content": "word " * 4} # 4.8 tokens
+ {"content": "1234"} # 1 token
]
}
- # Total is int(round(4.8)) + 50 = 5 + 50 = 55
- assert estimate_prompt_tokens(body) == 50 + 5
+ assert estimate_prompt_tokens(body) == 50 + 1
def test_estimate_prompt_tokens_missing_content():
body = {
diff --git a/router/tests/test_get_goose_sessions.py b/router/tests/test_get_goose_sessions.py
deleted file mode 100644
index 52640fef..00000000
--- a/router/tests/test_get_goose_sessions.py
+++ /dev/null
@@ -1,46 +0,0 @@
-import pytest
-import sys
-import os
-from pathlib import Path
-from unittest.mock import patch, MagicMock
-
-os.environ["CONFIG_PATH"] = str(Path(__file__).resolve().parent.parent / "config.yaml")
-sys.path.insert(0, str(Path(__file__).resolve().parent.parent))
-
-from main import get_goose_sessions
-
-def test_get_goose_sessions_no_db():
- with patch('os.path.exists', return_value=False):
- assert get_goose_sessions() == []
-
-def test_get_goose_sessions_success():
- mock_sqlite3 = MagicMock()
- mock_conn = MagicMock()
- mock_cursor = MagicMock()
-
- mock_sqlite3.connect.return_value = mock_conn
- mock_conn.cursor.return_value = mock_cursor
-
- mock_cursor.fetchall.return_value = [
- {"id": 1, "name": "s1"},
- {"id": 2, "name": "s2"}
- ]
-
- with patch('os.path.exists', return_value=True):
- with patch.dict(sys.modules, {'sqlite3': mock_sqlite3}):
- result = get_goose_sessions()
-
- assert len(result) == 2
- assert result[0] == {"id": 1, "name": "s1"}
- mock_sqlite3.connect.assert_called_once_with("/config/goose_sessions/sessions/sessions.db", timeout=1.0)
- mock_cursor.execute.assert_called_once()
- mock_conn.close.assert_called_once()
-
-def test_get_goose_sessions_exception():
- mock_sqlite3 = MagicMock()
- mock_sqlite3.connect.side_effect = Exception("DB error")
-
- with patch('os.path.exists', return_value=True):
- with patch.dict(sys.modules, {'sqlite3': mock_sqlite3}):
- result = get_goose_sessions()
- assert result == []
diff --git a/router/tests/test_get_live_gemini_oauth_token.py b/router/tests/test_get_live_gemini_oauth_token.py
deleted file mode 100644
index a494ad21..00000000
--- a/router/tests/test_get_live_gemini_oauth_token.py
+++ /dev/null
@@ -1,75 +0,0 @@
-import os
-import sys
-import json
-import time
-import pytest
-from unittest.mock import patch, mock_open
-
-# Add router to sys.path properly
-router_path = os.path.abspath(os.path.join(os.path.dirname(__file__), ".."))
-if router_path not in sys.path:
- sys.path.insert(0, router_path)
-
-with patch('builtins.open', mock_open(read_data='''
-server:
- host: 0.0.0.0
- port: 5000
-router:
- router_model:
- api_key: "dummy_key"
- model: "dummy_model"
-''')):
- import main
-
-def test_get_live_gemini_oauth_token_valid():
- """Test retrieving a valid, unexpired token."""
- mock_data = {
- "access_token": "valid_token_123",
- "expiry_date": int(time.time() * 1000) + 3600000 # 1 hour in the future
- }
- with patch("os.path.exists", return_value=True), \
- patch("builtins.open", mock_open(read_data=json.dumps(mock_data))), \
- patch("main.logger.info") as mock_logger:
- token = main.get_live_gemini_oauth_token()
- assert token == "valid_token_123"
- mock_logger.assert_called_with("🔑 Found valid, unexpired Gemini OAuth token from host!")
-
-def test_get_live_gemini_oauth_token_expired():
- """Test that an expired token returns None."""
- mock_data = {
- "access_token": "expired_token_456",
- "expiry_date": int(time.time() * 1000) - 3600000 # 1 hour in the past
- }
- with patch("os.path.exists", return_value=True), \
- patch("builtins.open", mock_open(read_data=json.dumps(mock_data))), \
- patch("main.logger.debug") as mock_logger:
- token = main.get_live_gemini_oauth_token()
- assert token is None
- mock_logger.assert_called_with("Gemini OAuth token on disk is expired — agy uses system keyring instead.")
-
-def test_get_live_gemini_oauth_token_missing_file():
- """Test behavior when the credentials file does not exist."""
- with patch("os.path.exists", return_value=False):
- token = main.get_live_gemini_oauth_token()
- assert token is None
-
-def test_get_live_gemini_oauth_token_invalid_json():
- """Test behavior when the credentials file contains invalid JSON."""
- with patch("os.path.exists", return_value=True), \
- patch("builtins.open", mock_open(read_data="invalid json")), \
- patch("main.logger.error") as mock_logger:
- token = main.get_live_gemini_oauth_token()
- assert token is None
- mock_logger.assert_called()
-
-def test_get_live_gemini_oauth_token_missing_access_token():
- """Test behavior when the JSON does not contain an access_token."""
- mock_data = {
- "expiry_date": int(time.time() * 1000) + 3600000
- }
- with patch("os.path.exists", return_value=True), \
- patch("builtins.open", mock_open(read_data=json.dumps(mock_data))), \
- patch("main.logger.debug") as mock_logger:
- token = main.get_live_gemini_oauth_token()
- assert token is None
- mock_logger.assert_called_with("Gemini OAuth token on disk is expired — agy uses system keyring instead.")
diff --git a/router/tests/test_get_redis.py b/router/tests/test_get_redis.py
deleted file mode 100644
index 0fdeaed2..00000000
--- a/router/tests/test_get_redis.py
+++ /dev/null
@@ -1,136 +0,0 @@
-import os
-import time
-from unittest.mock import patch, MagicMock
-
-import pytest
-
-import router.main as main
-
-@pytest.fixture(autouse=True)
-def reset_redis_globals():
- """Reset the global variables before and after each test."""
- original_client = main._redis_client
- original_last_attempt = main._redis_last_init_attempt
-
- main._redis_client = None
- main._redis_last_init_attempt = 0.0
-
- yield
-
- main._redis_client = original_client
- main._redis_last_init_attempt = original_last_attempt
-
-def test_get_redis_already_initialized():
- """If the client is already initialized, it should return the client immediately."""
- mock_client = MagicMock()
- main._redis_client = mock_client
-
- assert main.get_redis() is mock_client
-
-@patch("router.main.time.monotonic")
-def test_get_redis_cooldown(mock_monotonic):
- """If init failed recently, it should return None without attempting to initialize."""
- main._redis_client = None
- main._redis_last_init_attempt = 100.0
-
- # Time elapsed is less than 5.0 seconds
- mock_monotonic.return_value = 103.0
-
- assert main.get_redis() is None
-
-@patch("router.main.time.monotonic")
-@patch("router.main.aioredis.Redis")
-@patch.dict(os.environ, {"VALKEY_HOST": "my-host", "VALKEY_PORT": "1234"})
-def test_get_redis_initialization_success(mock_redis, mock_monotonic):
- """If sufficient time has passed, it should initialize and return the client."""
- main._redis_client = None
- main._redis_last_init_attempt = 100.0
-
- # Time elapsed is 10.0 seconds (greater than 5.0)
- mock_monotonic.return_value = 110.0
-
- mock_redis_instance = MagicMock()
- mock_redis.return_value = mock_redis_instance
-
- client = main.get_redis()
-
- assert client is mock_redis_instance
- assert main._redis_client is mock_redis_instance
- assert main._redis_last_init_attempt == 110.0
- mock_redis.assert_called_once_with(host="my-host", port=1234, decode_responses=True, socket_timeout=1.0)
-
-@patch("router.main.time.monotonic")
-@patch("router.main.logger.warning")
-@patch.dict(os.environ, {"VALKEY_HOST": "my-host", "VALKEY_PORT": "invalid"})
-def test_get_redis_initialization_failure(mock_logger_warning, mock_monotonic):
- """If initialization fails, it should catch the exception, log a warning, and return None."""
- main._redis_client = None
- main._redis_last_init_attempt = 100.0
-
- # Time elapsed is 10.0 seconds
- mock_monotonic.return_value = 110.0
-
- # The int() conversion of VALKEY_PORT will raise ValueError
- client = main.get_redis()
-
- assert client is None
- assert main._redis_client is None
- assert main._redis_last_init_attempt == 110.0
- mock_logger_warning.assert_called_once()
- assert "Failed to initialize Valkey client" in mock_logger_warning.call_args[0][0]
-
-@patch("router.main.time.monotonic")
-@patch("router.main.aioredis.Redis")
-@patch("router.main.logger.warning")
-@patch.dict(os.environ, {"VALKEY_HOST": "my-host", "VALKEY_PORT": "1234"})
-def test_get_redis_initialization_exception(mock_logger_warning, mock_redis, mock_monotonic):
- """If aioredis.Redis throws an exception, it should catch it and return None."""
- main._redis_client = None
- main._redis_last_init_attempt = 100.0
-
- mock_monotonic.return_value = 110.0
-
- mock_redis.side_effect = Exception("Test Exception")
-
- client = main.get_redis()
-
- assert client is None
- assert main._redis_client is None
- assert main._redis_last_init_attempt == 110.0
- mock_logger_warning.assert_called_once()
- assert "Test Exception" in mock_logger_warning.call_args[0][0]
-
-@patch("router.main.time.monotonic")
-@patch("router.main.aioredis.Redis.from_url")
-@patch.dict(os.environ, {"VALKEY_URL": "redis://my-url:1234"})
-def test_get_redis_simulation_flow_url(mock_from_url, mock_monotonic):
- """Simulate the full flow for from_url: failure -> cooldown -> success -> cached."""
- # State is reset by the autouse fixture reset_redis_globals
-
- # 1. First attempt fails
- mock_monotonic.return_value = 10.0
- mock_from_url.side_effect = Exception("Connection error")
- assert main.get_redis() is None
- assert main._redis_last_init_attempt == 10.0
-
- # 2. Second attempt during cooldown (e.g. 12.0s)
- mock_monotonic.return_value = 12.0
- mock_from_url.reset_mock()
- assert main.get_redis() is None
- mock_from_url.assert_not_called()
-
- # 3. Third attempt after cooldown (e.g. 16.0s) succeeds
- mock_monotonic.return_value = 16.0
- mock_redis_instance = MagicMock()
- mock_from_url.side_effect = None
- mock_from_url.return_value = mock_redis_instance
- client = main.get_redis()
- assert client is mock_redis_instance
- assert main._redis_client is mock_redis_instance
- mock_from_url.assert_called_once()
-
- # 4. Fourth attempt returns cached instance
- mock_monotonic.return_value = 18.0
- mock_from_url.reset_mock()
- assert main.get_redis() is mock_redis_instance
- mock_from_url.assert_not_called()
diff --git a/router/tests/test_load_persisted_stats.py b/router/tests/test_load_persisted_stats.py
deleted file mode 100644
index 76edbf51..00000000
--- a/router/tests/test_load_persisted_stats.py
+++ /dev/null
@@ -1,61 +0,0 @@
-import json
-import pytest
-from unittest.mock import patch, mock_open
-
-import router.main
-from router.main import load_persisted_stats
-
-@pytest.fixture
-def mock_stats():
- # Setup a clean stats dictionary for testing
- clean_stats = {
- "total_requests": 0,
- "nested_dict": {"a": 1, "b": 2},
- "existing_key": "value"
- }
- with patch.dict(router.main.stats, clean_stats, clear=True):
- yield router.main.stats
-
-def test_load_persisted_stats_file_not_exists(mock_stats):
- with patch("router.main.os.path.exists", return_value=False) as mock_exists:
- load_persisted_stats()
- mock_exists.assert_called_once_with(router.main.STATS_JSON_PATH)
- # Stats should remain unchanged
- assert mock_stats["total_requests"] == 0
-
-def test_load_persisted_stats_success(mock_stats):
- mock_data = {
- "total_requests": 100,
- "nested_dict": {"b": 3, "c": 4},
- "new_key": "new_value"
- }
- mock_json = json.dumps(mock_data)
-
- with patch("router.main.os.path.exists", return_value=True):
- with patch("router.main.open", mock_open(read_data=mock_json)):
- with patch("router.main.logger.info") as mock_logger:
- load_persisted_stats()
-
- # Assert simple value updated via else block
- assert mock_stats["total_requests"] == 100
- # Assert nested_dict updated via if block (b updated, c added, a unchanged)
- assert mock_stats["nested_dict"] == {"a": 1, "b": 3, "c": 4}
- # Assert new_key added via else block
- assert mock_stats["new_key"] == "new_value"
- # Assert existing_key unchanged
- assert mock_stats["existing_key"] == "value"
-
- mock_logger.assert_called_once_with("✓ Successfully loaded persisted gateway statistics from disk.")
-
-def test_load_persisted_stats_exception(mock_stats):
- with patch("router.main.os.path.exists", return_value=True):
- with patch("router.main.open", side_effect=Exception("Mock read error")):
- with patch("router.main.logger.error") as mock_logger:
- load_persisted_stats()
-
- # Stats should remain unchanged
- assert mock_stats["total_requests"] == 0
-
- # Error should be logged
- mock_logger.assert_called_once()
- assert "Failed to load persisted stats: Mock read error" in mock_logger.call_args[0][0]
diff --git a/router/tests/test_memory_mcp.py b/router/tests/test_memory_mcp.py
deleted file mode 100644
index 8c93f1f6..00000000
--- a/router/tests/test_memory_mcp.py
+++ /dev/null
@@ -1,313 +0,0 @@
-import json
-import re
-import sys
-import time
-from pathlib import Path
-
-# Dynamic project root discovery
-root = Path(__file__).resolve()
-while root.parent != root and not (root / ".git").exists():
- root = root.parent
-sys.path.insert(0, str(root))
-sys.path.insert(0, str(root / "router"))
-
-import pytest
-from memory_mcp import (
- PREFIX,
- SCOPE_GLOBAL,
- SCOPE_LOCAL,
- _make_key,
- _memory_entry,
- _memory_value,
- _parse_key,
- _parse_memory_value,
-)
-
-
-# =====================================================================
-# Tests from router/test_memory_mcp.py
-# =====================================================================
-
-def test_make_key_global():
- """Test generating a key for global scope."""
- category = "test_cat"
- data = "test_data"
-
- before_ts = int(time.time() * 1000)
- key = _make_key(category, True, data)
- after_ts = int(time.time() * 1000)
-
- # Expected format: f"{PREFIX}:{scope}:{category}::{ts}:{h}"
- assert key.startswith(f"{PREFIX}:{SCOPE_GLOBAL}:{category}::")
-
- # Extract timestamp and hash part
- match = re.match(rf"^{PREFIX}:{SCOPE_GLOBAL}:{category}::(\d+):([a-f0-9]+)$", key)
- assert match is not None, f"Key {key} does not match expected format"
-
- ts = int(match.group(1))
- h = match.group(2)
-
- assert before_ts <= ts <= after_ts
- assert len(h) == 20
-
-
-def test_make_key_local():
- """Test generating a key for local scope."""
- category = "another_cat"
- data = "more_data"
-
- before_ts = int(time.time() * 1000)
- key = _make_key(category, False, data)
- after_ts = int(time.time() * 1000)
-
- assert key.startswith(f"{PREFIX}:{SCOPE_LOCAL}:{category}::")
-
- match = re.match(rf"^{PREFIX}:{SCOPE_LOCAL}:{category}::(\d+):([a-f0-9]+)$", key)
- assert match is not None, f"Key {key} does not match expected format"
-
- ts = int(match.group(1))
- h = match.group(2)
-
- assert before_ts <= ts <= after_ts
- assert len(h) == 20
-
-
-def test_make_key_formatting_details(monkeypatch):
- """Test the exact output formatting of _make_key using deterministic BLAKE2b."""
- # Mock time.time to return a predictable float so ts = 1620000000123
- monkeypatch.setattr(time, "time", lambda: 1620000000.123)
-
- # data="data", ts=1620000000123 -> blake2b("data1620000000123", digest_size=10) -> 5e5dad075ca7764bc51f
- key1 = _make_key("cat1", True, "data")
- assert key1 == f"{PREFIX}:{SCOPE_GLOBAL}:cat1::1620000000123:5e5dad075ca7764bc51f"
-
- key2 = _make_key("cat2", False, "data")
- assert key2 == f"{PREFIX}:{SCOPE_LOCAL}:cat2::1620000000123:5e5dad075ca7764bc51f"
-
-
-def test_make_key_determinism_and_uniqueness():
- """Test determinism for same inputs within same timestamp, and uniqueness across timestamps/data."""
- category = "test_cat"
- data1 = "data1"
- data2 = "data2"
-
- key1 = _make_key(category, True, data1)
- time.sleep(0.002)
- key2 = _make_key(category, True, data1)
- key3 = _make_key(category, True, data2)
-
- # Uniqueness across data
- assert key1 != key3
-
- # Check determinism: if the timestamp parts are the same, the keys should be identical
- ts1 = key1.split("::")[1].split(":")[0]
- ts2 = key2.split("::")[1].split(":")[0]
- if ts1 == ts2:
- assert key1 == key2
- else:
- # If timestamp is different, keys should be different
- assert key1 != key2
-
-
-def test_memory_value_happy_path():
- """Test _memory_value with standard data and tags."""
- result = _memory_value("some data", ["tag1", "tag2"])
- parsed = json.loads(result)
- assert parsed == {"data": "some data", "tags": ["tag1", "tag2"]}
-
-
-def test_memory_value_missing_tags():
- """Test _memory_value when tags is None."""
- result = _memory_value("some data", None)
- parsed = json.loads(result)
- assert parsed == {"data": "some data", "tags": []}
-
-
-def test_memory_value_unicode():
- """Test _memory_value properly handles unicode and ensure_ascii=False."""
- result = _memory_value("こんにちは", ["世界"])
- # If ensure_ascii=False, the unicode characters shouldn't be escaped (no \uXXXX)
- assert "こんにちは" in result
- assert "世界" in result
- parsed = json.loads(result)
- assert parsed == {"data": "こんにちは", "tags": ["世界"]}
-
-
-def test_parse_memory_value_success():
- """Test _parse_memory_value successfully decodes valid JSON."""
- raw = '{"data": "info", "tags": ["a"]}'
- result = _parse_memory_value(raw)
- assert result == {"data": "info", "tags": ["a"]}
-
-
-def test_parse_memory_value_invalid_json():
- """Test _parse_memory_value with invalid JSON."""
- result = _parse_memory_value("{invalid_json:")
- assert result == {"data": "{invalid_json:", "tags": []}
-
-
-def test_parse_memory_value_type_error():
- """Test _parse_memory_value with TypeError (e.g. passing None)."""
- result = _parse_memory_value(None)
- assert result == {"data": None, "tags": []}
-
-
-def test_parse_memory_value_invalid_json_string():
- """Test _parse_memory_value with invalid JSON string."""
- result = _parse_memory_value("this is not a valid json string")
- assert result == {"data": "this is not a valid json string", "tags": []}
-
-
-# =====================================================================
-# Tests from test_memory_mcp.py (root)
-# =====================================================================
-
-def test_memory_entry_happy_path():
- """Test correctly formatted and complete memory entry."""
- valid_key = "memory:global:project_standards::1689201948123:a1b2c3d4e5f6"
- valid_value = json.dumps({"data": "Use pytest for all tests", "tags": ["testing", "python"]})
- lmem = {
- "key": valid_key,
- "value": valid_value,
- "memory_id": "test_id_123"
- }
-
- result = _memory_entry(lmem)
-
- assert result is not None
- assert result["key"] == valid_key
- assert result["category"] == "project_standards"
- assert result["data"] == "Use pytest for all tests"
- assert result["tags"] == ["testing", "python"]
- assert result["scope"] == "global"
- assert result["timestamp"] == "1689201948123"
- assert result["memory_id"] == "test_id_123"
-
-
-def test_memory_entry_invalid_key():
- """Test with a key that does not start with 'memory:'."""
- lmem = {
- "key": "notamemory:global:cat::123:hash",
- "value": json.dumps({"data": "test", "tags": []})
- }
-
- result = _memory_entry(lmem)
- assert result is None
-
-
-def test_memory_entry_malformed_json_value():
- """Test with malformed/string value where JSON parsing fails."""
- valid_key = "memory:local:notes::1689201948123:a1b2c3d4e5f6"
- # value is just a raw string, not JSON
- lmem = {
- "key": valid_key,
- "value": "This is just a raw string without tags"
- }
-
- result = _memory_entry(lmem)
-
- assert result is not None
- assert result["data"] == "This is just a raw string without tags"
- assert result["tags"] == [] # Falls back to empty tags list
- assert result["category"] == "notes"
- assert result["scope"] == "local"
-
-
-def test_memory_entry_missing_fields():
- """Test gracefully handling dictionaries with missing keys."""
- # Missing 'value' and 'memory_id'
- lmem1 = {
- "key": "memory:global:ideas::123:hash"
- }
- result1 = _memory_entry(lmem1)
- assert result1 is not None
- assert result1["data"] == ""
- assert result1["tags"] == []
- assert result1["memory_id"] == ""
-
- # Missing 'key'
- lmem2 = {
- "value": json.dumps({"data": "test", "tags": []})
- }
- result2 = _memory_entry(lmem2)
- assert result2 is None
-
- # Empty dict
- result3 = _memory_entry({})
- assert result3 is None
-
-
-@pytest.mark.parametrize(
- "key, expected",
- [
- (
- "memory:local:code::20240101T120000Z:abc123hash",
- {"scope": "local", "category": "code", "timestamp": "20240101T120000Z"},
- ),
- (
- "memory:global:general",
- {"scope": "global", "category": "general", "timestamp": ""},
- ),
- (
- "memory:local::20240101T120000Z:abc123hash",
- {"scope": "local", "category": "", "timestamp": "20240101T120000Z"},
- ),
- (
- "memory",
- {"scope": "", "category": "", "timestamp": ""},
- ),
- (
- "",
- {"scope": "", "category": "", "timestamp": ""},
- ),
- (
- None,
- {"scope": "", "category": "", "timestamp": ""},
- ),
- (
- "memory:global:category:with:colons::20240101T120000Z:abc123hash",
- {"scope": "global", "category": "category", "timestamp": "20240101T120000Z"},
- ),
- (
- "memory:global:general::20240101T120000Z",
- {"scope": "global", "category": "general", "timestamp": "20240101T120000Z"},
- ),
- ],
- ids=[
- "happy_path",
- "missing_timestamp_hash",
- "missing_category",
- "missing_scope_and_category",
- "empty_string",
- "invalid_type",
- "extra_colons_in_category",
- "missing_hash_but_has_timestamp",
- ]
-)
-def test_parse_key(key, expected):
- """Test _parse_key with various valid and invalid formats."""
- result = _parse_key(key)
- assert result == expected
-
-def test_parse_memory_value_valid_json():
- raw_data = json.dumps({"data": "some data", "tags": ["tag1", "tag2"]})
- result = _parse_memory_value(raw_data)
- assert result == {"data": "some data", "tags": ["tag1", "tag2"]}
-
-
-def test_parse_memory_value_invalid_json():
- raw_data = "this is not json"
- result = _parse_memory_value(raw_data)
- assert result == {"data": "this is not json", "tags": []}
-
-
-def test_parse_memory_value_type_error():
- raw_data = 12345
- result = _parse_memory_value(raw_data) # type: ignore[arg-type]
- assert result == {"data": 12345, "tags": []}
-
-
-def test_parse_memory_value_non_dict_json():
- raw_data = '"just a string"'
- result = _parse_memory_value(raw_data)
- assert result == "just a string"
diff --git a/scripts/README.md b/scripts/README.md
index 29bf80a4..0139e8d3 100644
--- a/scripts/README.md
+++ b/scripts/README.md
@@ -4,7 +4,7 @@ This directory and the repository root contain various scripts used for stack or
---
-## 1. Stack Orchestration, Backups, and PR Utilities
+## 1. Stack Orchestration & Backups
### `start-stack.sh` (Root Directory)
Unified startup and credential extraction script for the Podman Kubernetes container stack.
@@ -16,13 +16,6 @@ Unified startup and credential extraction script for the Podman Kubernetes conta
### `scripts/backup.sh`
Automated database backup script that runs before every stack deployment. Uses `pg_isready` to safely wait for database connections and manages timestamped backups under `backups/`.
-### `scripts/get_pr_status.py`
-A CLI utility to fetch and print the status of a GitHub PR (its state, review decisions, and checks status rollup) using the `gh` CLI.
-- **Usage**:
- - `python3 scripts/get_pr_status.py` (Fetches status of the current branch's PR)
- - `python3 scripts/get_pr_status.py
` (Fetches status for the specified PR ID)
-
-
---
## 2. Routing & Cooldown Verification Scripts
@@ -86,12 +79,6 @@ The integration test suite is located in the root directory. Tests are categoriz
### Performance & Monitoring Tests
- **`test_stream_latency.py`**: Measures Time-To-First-Token (TTFT) and token generation speed.
-### Dashboard & Annotations Tests
-- **`tests/test_read_annotations_async.py`**: Unit tests for the asynchronous dashboard annotation reading and caching mechanism.
-
-### Utility Script Tests
-- **`tests/test_get_pr_status.py`**: Unit tests validating command execution, status fetching, and error/timeout handling in `scripts/get_pr_status.py`.
-
### Simulation Tests
- **`test_agy_behavior.py`**: Asserts the behavior of the `agy` CLI client under quota limits.
- **`test_quota_reset.sh`**: Simulates/triggers quota reset conditions.
diff --git a/scripts/benchmark_tokens.py b/scripts/benchmark_tokens.py
deleted file mode 100644
index d701b4eb..00000000
--- a/scripts/benchmark_tokens.py
+++ /dev/null
@@ -1,76 +0,0 @@
-import sys
-import os
-from pathlib import Path
-
-# Set CONFIG_PATH and ROUTER_API_KEY for import
-os.environ["CONFIG_PATH"] = str(Path(__file__).resolve().parent.parent / "router" / "config.yaml")
-os.environ["ROUTER_API_KEY"] = "local-token"
-# Add the parent directory and the router directory to the path
-sys.path.insert(0, str(Path(__file__).resolve().parent.parent))
-sys.path.insert(0, str(Path(__file__).resolve().parent.parent / "router"))
-
-from router.main import estimate_prompt_tokens
-
-def verify_accuracy():
- """Benchmarking utility to verify token estimation accuracy across content types."""
- # Test cases inspired by the problem description
- test_cases = [
- {
- "name": "English prose",
- "content": "This is a standard English prose sentence intended to evaluate the accuracy of the token estimation heuristic for typical content. " * 5,
- "actual_tokens": 110,
- },
- {
- "name": "Python code",
- "content": """
-def calculate_factorial(n):
- if n == 0:
- return 1
- else:
- return n * calculate_factorial(n-1)
-
-for i in range(10):
- print(f"Factorial of {i} is {calculate_factorial(i)}")
-""" * 3,
- "actual_tokens": 150,
- },
- {
- "name": "CJK text",
- "content": "这是一个测试，用于验证中文字符的令牌估算逻辑。它应该比字符计数更准确。" * 5,
- "actual_tokens": 60,
- },
- {
- "name": "Whitespace-padded JSON",
- "content": '{\n "key": "value",\n "nested": {\n "inner": "data"\n }\n}\n' * 5,
- "actual_tokens": 60,
- },
- {
- "name": "Emoji",
- "content": "🚀🔥-🤖✨-📈💎-🚨🛠️-🌐" * 5,
- "actual_tokens": 25,
- }
- ]
-
- print(f"{'Case':<25} | {'Actual':<7} | {'Estimated':<9} | {'Error':<7}")
- print("-" * 55)
-
- all_passed = True
- for case in test_cases:
- body = {"messages": [{"content": case["content"]}]}
- est = estimate_prompt_tokens(body) - 50 # Subtract metadata overhead
- error = abs(est - case["actual_tokens"]) / case["actual_tokens"]
- print(f"{case['name']:<25} | {case['actual_tokens']:<7} | {est:<9} | {error:.1%}")
- # Acceptance criteria: within ±25% for these rough heuristics
- if error > 0.25:
- print(f" --> FAILURE: {case['name']} error exceeds target threshold")
- all_passed = False
-
- assert all_passed, "Token estimation accuracy benchmark failed"
-
-if __name__ == "__main__":
- try:
- verify_accuracy()
- sys.exit(0)
- except AssertionError as e:
- print(f"\nERROR: {e}")
- sys.exit(1)
diff --git a/scripts/get_pr_status.py b/scripts/get_pr_status.py
deleted file mode 100644
index d65f65f1..00000000
--- a/scripts/get_pr_status.py
+++ /dev/null
@@ -1,59 +0,0 @@
-#!/usr/bin/env python3
-import subprocess
-import json
-import sys
-from typing import Sequence
-
-
-def run_cmd(argv: Sequence[str]) -> str:
- """Runs a command and returns stripped stdout."""
- result = subprocess.run(argv, shell=False, capture_output=True, text=True, check=True, timeout=30)
- return result.stdout.strip()
-
-
-def get_pr_status(pr_id: str = "") -> None:
- """Fetches and prints the status of a PR using gh CLI."""
- cmd = ["gh", "pr", "view"]
- if pr_id:
- cmd.append(pr_id)
- cmd.extend(["--json", "state,reviewDecision,statusCheckRollup"])
-
- try:
- output = run_cmd(cmd)
- data = json.loads(output)
-
- state = data.get("state")
- review = data.get("reviewDecision") or "NONE"
- checks = data.get("statusCheckRollup", [])
-
- # Summarize checks
- success_count = 0
- total_count = len(checks)
- for check in checks:
- # gh CLI returns conclusion for CheckRun and state for StatusContext
- conclusion = check.get("conclusion") or check.get("state")
- if conclusion == "SUCCESS":
- success_count += 1
-
- print(f"PR Status: {state}")
- print(f"Review Decision: {review}")
- print(f"Checks: {success_count}/{total_count} passed")
-
- except subprocess.CalledProcessError as e:
- print(f"Error: Failed to fetch PR status: {e.stderr.strip()}", file=sys.stderr)
- sys.exit(1)
- except json.JSONDecodeError:
- print("Error: Failed to parse gh CLI output", file=sys.stderr)
- sys.exit(1)
- except Exception as e:
- print(f"An unexpected error occurred: {e}", file=sys.stderr)
- sys.exit(1)
-
-
-def main():
- pr_id = sys.argv[1] if len(sys.argv) > 1 else ""
- get_pr_status(pr_id)
-
-
-if __name__ == "__main__":
- main()
diff --git a/start-stack.sh b/start-stack.sh
index 03bb1220..c9b826dc 100755
--- a/start-stack.sh
+++ b/start-stack.sh
@@ -31,6 +31,12 @@ if [ -f "$ENV_FILE" ]; then
fi
# Ensure openssl is installed if we need to generate passwords/keys
+if [ -z "$POSTGRES_PASSWORD" ] || [ -z "$NEXTAUTH_SECRET" ] || [ -z "$SALT" ] || [ -z "$ENCRYPTION_KEY" ] || [ -z "$LITELLM_MASTER_KEY" ]; then
+ if ! command -v openssl &>/dev/null; then
+ echo "❌ Error: 'openssl' is required to generate secure random keys but was not found in PATH."
+ exit 1
+ fi
+fi
if [ -z "$OPENROUTER_API_KEY" ]; then
@@ -95,7 +101,7 @@ else
echo "⚠️ Warning: Host agy daemon not responding on port 5005"
fi
-if [ -z "$POSTGRES_PASSWORD" ] || [ -z "$NEXTAUTH_SECRET" ] || [ -z "$SALT" ] || [ -z "$ENCRYPTION_KEY" ] || [ -z "$LITELLM_MASTER_KEY" ] || [ -z "$ROUTER_API_KEY" ] || [ -z "$MINIO_ROOT_USER" ] || [ -z "$MINIO_ROOT_PASSWORD" ]; then
+if [ -z "$NEXTAUTH_SECRET" ] || [ -z "$SALT" ] || [ -z "$ENCRYPTION_KEY" ] || [ -z "$LITELLM_MASTER_KEY" ] || [ -z "$ROUTER_API_KEY" ]; then
if ! command -v openssl &>/dev/null; then
echo "❌ Error: 'openssl' is required to generate secure random keys but was not found in PATH."
exit 1
@@ -135,43 +141,12 @@ if [ -z "$LITELLM_MASTER_KEY" ]; then
exit 1
fi
-if [ -z "$LANGFUSE_INIT_USER_PASSWORD" ]; then
- LANGFUSE_INIT_USER_PASSWORD="$(openssl rand -hex 16)"
- echo "LANGFUSE_INIT_USER_PASSWORD=\"$LANGFUSE_INIT_USER_PASSWORD\"" >> "$ENV_FILE"
- echo "✓ Generated new LANGFUSE_INIT_USER_PASSWORD and saved to $ENV_FILE"
-fi
-
-if [ -z "$REDIS_AUTH" ]; then
- REDIS_AUTH="$(openssl rand -hex 16)"
- echo "REDIS_AUTH=\"$REDIS_AUTH\"" >> "$ENV_FILE"
- echo "✓ Generated new REDIS_AUTH and saved to $ENV_FILE"
-fi
-
-if [ -z "$CLICKHOUSE_PASSWORD" ]; then
- CLICKHOUSE_PASSWORD="$(openssl rand -hex 16)"
- echo "CLICKHOUSE_PASSWORD=\"$CLICKHOUSE_PASSWORD\"" >> "$ENV_FILE"
- echo "✓ Generated new CLICKHOUSE_PASSWORD and saved to $ENV_FILE"
-fi
-
if [ -z "$ROUTER_API_KEY" ]; then
ROUTER_API_KEY="$(openssl rand -hex 32)"
echo "ROUTER_API_KEY=\"$ROUTER_API_KEY\"" >> "$ENV_FILE"
echo "✓ Generated new ROUTER_API_KEY and saved to $ENV_FILE"
fi
-if [ -z "$MINIO_ROOT_USER" ]; then
- MINIO_ROOT_USER="minio-$(openssl rand -hex 4)"
- echo "MINIO_ROOT_USER=\"$MINIO_ROOT_USER\"" >> "$ENV_FILE"
- echo "✓ Generated new MINIO_ROOT_USER and saved to $ENV_FILE"
-fi
-
-if [ -z "$MINIO_ROOT_PASSWORD" ]; then
- MINIO_ROOT_PASSWORD="$(openssl rand -hex 16)"
- echo "MINIO_ROOT_PASSWORD=\"$MINIO_ROOT_PASSWORD\"" >> "$ENV_FILE"
- echo "✓ Generated new MINIO_ROOT_PASSWORD and saved to $ENV_FILE"
-fi
-
-
# DYNAMIC_LITELLM_MASTER_KEY_PLACEHOLDER in router config is resolved at runtime from env
@@ -280,7 +255,7 @@ setup_minio_buckets() {
# Ensure mc alias points to the correct MinIO S3 API port (9002, not 9000)
# The default 'local' alias in the MinIO image points to :9000 which is ClickHouse,
# not MinIO. We must override it.
- podman exec agent-router-pod-minio-s3 mc alias set local http://127.0.0.1:9002 "$MINIO_ROOT_USER" "$MINIO_ROOT_PASSWORD" 2>/dev/null
+ podman exec agent-router-pod-minio-s3 mc alias set local http://127.0.0.1:9002 minioadmin minioadmin 2>/dev/null
# Create required buckets (idempotent)
local BUCKETS=("langfuse-events" "proj-triage-gateway-id")
@@ -381,7 +356,7 @@ if podman pod exists agent-router-pod 2>/dev/null; then
fi
render_pod_yaml() {
- export WORKDIR HOME LITELLM_MASTER_KEY POSTGRES_PASSWORD NEXTAUTH_SECRET SALT ENCRYPTION_KEY LANGFUSE_INIT_USER_PASSWORD MINIO_ROOT_USER MINIO_ROOT_PASSWORD
+ export WORKDIR HOME LITELLM_MASTER_KEY POSTGRES_PASSWORD NEXTAUTH_SECRET SALT ENCRYPTION_KEY
python3 - "$WORKDIR/pod.yaml" <<'PY'
import os, sys, urllib.parse
uid = os.getuid()
@@ -396,14 +371,11 @@ placeholders = [
"NEXTAUTH_SECRET_PLACEHOLDER",
"SALT_PLACEHOLDER",
"ENCRYPTION_KEY_PLACEHOLDER",
- "postgres-password-***",
- "MINIO_USER_PLACEHOLDER",
- "MINIO_PASSWORD_PLACEHOLDER"
- "LANGFUSE_INIT_USER_PASSWORD_PLACEHOLDER"
+ "postgres-password-***"
]
for ph in placeholders:
if ph not in text:
- sys.stderr.write(f"Error: Required placeholder '{ph}' not found in pod.yaml. Ensure you are using the latest version of the template.\n")
+ sys.stderr.write(f"Error: Required placeholder '{ph}' not found in pod.yaml\n")
sys.exit(1)
text = text.replace("/home/gpav/Vrac/LAB/AI/LLM-Routing", os.environ["WORKDIR"])
text = text.replace("/home/gpav/", os.environ["HOME"] + "/")
@@ -416,9 +388,6 @@ text = text.replace("postgres-password-***", os.environ["POSTGRES_PASSWORD"])
text = text.replace("NEXTAUTH_SECRET_PLACEHOLDER", os.environ["NEXTAUTH_SECRET"])
text = text.replace("SALT_PLACEHOLDER", os.environ["SALT"])
text = text.replace("ENCRYPTION_KEY_PLACEHOLDER", os.environ["ENCRYPTION_KEY"])
-text = text.replace("MINIO_USER_PLACEHOLDER", os.environ["MINIO_ROOT_USER"])
-text = text.replace("MINIO_PASSWORD_PLACEHOLDER", os.environ["MINIO_ROOT_PASSWORD"])
-text = text.replace("LANGFUSE_INIT_USER_PASSWORD_PLACEHOLDER", os.environ["LANGFUSE_INIT_USER_PASSWORD"])
sys.stdout.write(text)
PY
}
diff --git a/test_host_agy_daemon.py b/test_host_agy_daemon.py
deleted file mode 100644
index e0cae61c..00000000
--- a/test_host_agy_daemon.py
+++ /dev/null
@@ -1,44 +0,0 @@
-import os
-import json
-import pytest
-from unittest.mock import patch, mock_open
-
-import host_agy_daemon
-
-def test_get_last_conversation_id_success(monkeypatch):
- test_data = {"/test/path": "conv_123"}
- monkeypatch.setattr(os, "getcwd", lambda: "/test/path")
- monkeypatch.setattr(os.path, "exists", lambda x: True)
-
- m_open = mock_open(read_data=json.dumps(test_data))
- with patch("builtins.open", m_open):
- assert host_agy_daemon.get_last_conversation_id() == "conv_123"
-
-def test_get_last_conversation_id_not_found(monkeypatch):
- test_data = {"/other/path": "conv_123"}
- monkeypatch.setattr(os, "getcwd", lambda: "/test/path")
- monkeypatch.setattr(os.path, "exists", lambda x: True)
-
- m_open = mock_open(read_data=json.dumps(test_data))
- with patch("builtins.open", m_open):
- assert host_agy_daemon.get_last_conversation_id() is None
-
-def test_get_last_conversation_id_file_missing(monkeypatch):
- monkeypatch.setattr(os.path, "exists", lambda x: False)
- assert host_agy_daemon.get_last_conversation_id() is None
-
-def test_get_last_conversation_id_exception(monkeypatch):
- monkeypatch.setattr(os.path, "exists", lambda x: True)
- # Invalid JSON to trigger JSONDecodeError
- m_open = mock_open(read_data="{invalid json")
- with patch("builtins.open", m_open):
- assert host_agy_daemon.get_last_conversation_id() is None
-
-def test_get_last_conversation_id_io_error(monkeypatch):
- monkeypatch.setattr(os.path, "exists", lambda x: True)
-
- def raise_error(*args, **kwargs):
- raise IOError("permission denied")
-
- with patch("builtins.open", side_effect=raise_error):
- assert host_agy_daemon.get_last_conversation_id() is None
diff --git a/test_pie_chart_gradient.py b/test_pie_chart_gradient.py
index c9e85499..1d9a33bd 100644
--- a/test_pie_chart_gradient.py
+++ b/test_pie_chart_gradient.py
@@ -4,26 +4,22 @@
@pytest.fixture
def mock_stats():
- # Patch router.main.stats with a real dictionary containing tool_tokens
- # to ensure the function under test reads from the correct key.
- test_stats = {
- "tool_tokens": {
- "tree": 0,
- "shell": 0,
- "write": 0,
- "view": 0,
- "other": 0
- }
- }
- with patch("router.main.stats", test_stats):
- yield test_stats
+ with patch("router.main.stats") as mock_stats_obj:
+ yield mock_stats_obj
def test_get_pie_chart_gradient_empty(mock_stats):
+ mock_stats.__getitem__.return_value = {
+ "tree": 0,
+ "shell": 0,
+ "write": 0,
+ "view": 0,
+ "other": 0
+ }
result = get_pie_chart_gradient()
assert result == "background: rgba(255, 255, 255, 0.05);"
def test_get_pie_chart_gradient_one_tool(mock_stats):
- mock_stats["tool_tokens"] = {
+ mock_stats.__getitem__.return_value = {
"tree": 100,
"shell": 0,
"write": 0,
@@ -34,7 +30,7 @@ def test_get_pie_chart_gradient_one_tool(mock_stats):
assert result == "background: conic-gradient(#34d399 0.0% 100.0%);"
def test_get_pie_chart_gradient_multiple_tools(mock_stats):
- mock_stats["tool_tokens"] = {
+ mock_stats.__getitem__.return_value = {
"tree": 50,
"shell": 25,
"write": 25,
@@ -45,7 +41,7 @@ def test_get_pie_chart_gradient_multiple_tools(mock_stats):
assert result == "background: conic-gradient(#34d399 0.0% 50.0%, #fbbf24 50.0% 75.0%, #a78bfa 75.0% 100.0%);"
def test_get_pie_chart_gradient_unrecognized_tool(mock_stats):
- mock_stats["tool_tokens"] = {
+ mock_stats.__getitem__.return_value = {
"unknown_tool": 100
}
result = get_pie_chart_gradient()
diff --git a/tests/test_get_pr_status.py b/tests/test_get_pr_status.py
deleted file mode 100644
index 93885a14..00000000
--- a/tests/test_get_pr_status.py
+++ /dev/null
@@ -1,84 +0,0 @@
-import pytest
-import subprocess
-import json
-from unittest.mock import patch, MagicMock
-from scripts.get_pr_status import run_cmd, get_pr_status
-
-def test_run_cmd_success():
- output = run_cmd(["echo", "hello"])
- assert output == "hello"
-
-def test_run_cmd_strips_whitespace():
- output = run_cmd(["echo", " hello "])
- assert output == "hello"
-
-def test_run_cmd_error():
- with pytest.raises(subprocess.CalledProcessError):
- run_cmd(["false"])
-
-@patch("scripts.get_pr_status.subprocess.run")
-def test_run_cmd_timeout(mock_run):
- # run_cmd has a 30s timeout. We mock subprocess.run to raise it immediately.
- mock_run.side_effect = subprocess.TimeoutExpired(["sleep", "0.1"], 30)
- with pytest.raises(subprocess.TimeoutExpired):
- run_cmd(["sleep", "0.1"])
-
-@patch("scripts.get_pr_status.run_cmd")
-def test_get_pr_status_success(mock_run_cmd, capsys):
- mock_data = {
- "state": "OPEN",
- "reviewDecision": "APPROVED",
- "statusCheckRollup": [
- {"conclusion": "SUCCESS", "name": "test1"},
- {"state": "SUCCESS", "name": "test2"},
- {"conclusion": "FAILURE", "name": "test3"}
- ]
- }
- mock_run_cmd.return_value = json.dumps(mock_data)
-
- get_pr_status("123")
-
- captured = capsys.readouterr()
- assert "PR Status: OPEN" in captured.out
- assert "Review Decision: APPROVED" in captured.out
- assert "Checks: 2/3 passed" in captured.out
- mock_run_cmd.assert_called_once_with(["gh", "pr", "view", "123", "--json", "state,reviewDecision,statusCheckRollup"])
-
-@patch("scripts.get_pr_status.run_cmd")
-def test_get_pr_status_no_id(mock_run_cmd, capsys):
- mock_data = {
- "state": "MERGED",
- "reviewDecision": None,
- "statusCheckRollup": []
- }
- mock_run_cmd.return_value = json.dumps(mock_data)
-
- get_pr_status()
-
- captured = capsys.readouterr()
- assert "PR Status: MERGED" in captured.out
- assert "Review Decision: NONE" in captured.out
- assert "Checks: 0/0 passed" in captured.out
- mock_run_cmd.assert_called_once_with(["gh", "pr", "view", "--json", "state,reviewDecision,statusCheckRollup"])
-
-@patch("scripts.get_pr_status.run_cmd")
-def test_get_pr_status_error(mock_run_cmd, capsys):
- mock_run_cmd.side_effect = subprocess.CalledProcessError(1, ["gh"], stderr="gh not found")
-
- with pytest.raises(SystemExit) as e:
- get_pr_status("123")
-
- assert e.value.code == 1
- captured = capsys.readouterr()
- assert "Error: Failed to fetch PR status: gh not found" in captured.err
-
-@patch("scripts.get_pr_status.run_cmd")
-def test_get_pr_status_invalid_json(mock_run_cmd, capsys):
- mock_run_cmd.return_value = "invalid json"
-
- with pytest.raises(SystemExit) as e:
- get_pr_status("123")
-
- assert e.value.code == 1
- captured = capsys.readouterr()
- assert "Error: Failed to parse gh CLI output" in captured.err
diff --git a/tests/test_read_annotations_async.py b/tests/test_read_annotations_async.py
deleted file mode 100644
index b401bc8b..00000000
--- a/tests/test_read_annotations_async.py
+++ /dev/null
@@ -1,128 +0,0 @@
-import pytest
-from unittest.mock import patch, AsyncMock, MagicMock
-import copy
-import sys
-import os
-import json
-import asyncio
-
-# Ensure the root directory is in the path
-sys.path.insert(0, os.path.abspath(os.path.join(os.path.dirname(__file__), "..")))
-
-import router.main
-from router.main import _read_annotations_async
-
-@pytest.fixture(autouse=True)
-def clear_cache():
- router.main._annotations_cache.clear()
- yield
-
-@pytest.mark.asyncio
-async def test_read_annotations_async_initial_read():
- fake_path = "/tmp/annotations.json"
- fake_data = {"annotation1": "data1"}
-
- # Mock aiofiles.open
- mock_file = AsyncMock()
- mock_file.read.return_value = '{"annotation1": "data1"}'
-
- mock_context_manager = MagicMock()
- mock_context_manager.__aenter__ = AsyncMock(return_value=mock_file)
- mock_context_manager.__aexit__ = AsyncMock(return_value=False)
-
- mock_aiofiles_open = MagicMock(return_value=mock_context_manager)
-
- with patch("os.path.getmtime", return_value=100.0) as mock_getmtime, \
- patch("aiofiles.open", mock_aiofiles_open) as mock_open:
-
- result = await _read_annotations_async(fake_path)
-
- mock_getmtime.assert_called_once_with(fake_path)
- mock_open.assert_called_once_with(fake_path, "r", encoding="utf-8")
- assert result == fake_data
-
- # Verify cache is populated
- assert fake_path in router.main._annotations_cache
- assert router.main._annotations_cache[fake_path]["mtime"] == 100.0
- assert router.main._annotations_cache[fake_path]["data"] == fake_data
-
-@pytest.mark.asyncio
-async def test_read_annotations_async_cache_hit():
- fake_path = "/tmp/annotations.json"
- fake_data = {"annotation1": "data1"}
-
- # Pre-populate cache
- router.main._annotations_cache[fake_path] = {"mtime": 100.0, "data": fake_data}
-
- # Mock aiofiles.open (should NOT be called)
- mock_aiofiles_open = MagicMock()
-
- with patch("os.path.getmtime", return_value=100.0) as mock_getmtime, \
- patch("aiofiles.open", mock_aiofiles_open) as mock_open:
-
- result = await _read_annotations_async(fake_path)
-
- mock_getmtime.assert_called_once_with(fake_path)
- mock_open.assert_not_called()
- assert result == fake_data
-
-@pytest.mark.asyncio
-async def test_read_annotations_async_cache_invalidation():
- fake_path = "/tmp/annotations.json"
- fake_data_old = {"annotation1": "data1"}
- fake_data_new = {"annotation2": "data2"}
-
- # Pre-populate cache with old mtime
- router.main._annotations_cache[fake_path] = {"mtime": 100.0, "data": fake_data_old}
-
- mock_file = AsyncMock()
- mock_file.read.return_value = '{"annotation2": "data2"}'
-
- mock_context_manager = MagicMock()
- mock_context_manager.__aenter__ = AsyncMock(return_value=mock_file)
- mock_context_manager.__aexit__ = AsyncMock(return_value=False)
-
- mock_aiofiles_open = MagicMock(return_value=mock_context_manager)
-
- with patch("os.path.getmtime", return_value=200.0) as mock_getmtime, \
- patch("aiofiles.open", mock_aiofiles_open) as mock_open:
-
- result = await _read_annotations_async(fake_path)
-
- mock_getmtime.assert_called_once_with(fake_path)
- mock_open.assert_called_once_with(fake_path, "r", encoding="utf-8")
- assert result == fake_data_new
-
- # Verify cache is updated
- assert router.main._annotations_cache[fake_path]["mtime"] == 200.0
- assert router.main._annotations_cache[fake_path]["data"] == fake_data_new
-
-@pytest.mark.asyncio
-async def test_read_annotations_async_deepcopy():
- fake_path = "/tmp/annotations.json"
- fake_data = {"annotation1": {"nested": "value"}}
-
- # Pre-populate cache
- router.main._annotations_cache[fake_path] = {"mtime": 100.0, "data": fake_data}
-
- with patch("os.path.getmtime", return_value=100.0):
- # First read
- result1 = await _read_annotations_async(fake_path)
-
- # Mutate the result
- result1["annotation1"]["nested"] = "mutated"
-
- # Second read
- result2 = await _read_annotations_async(fake_path)
-
- # Verify second read returns original data, not mutated
- assert result2["annotation1"]["nested"] == "value"
- assert router.main._annotations_cache[fake_path]["data"]["annotation1"]["nested"] == "value"
-
-@pytest.mark.asyncio
-async def test_read_annotations_async_file_not_found():
- fake_path = "/tmp/annotations.json"
-
- with patch("os.path.getmtime", side_effect=FileNotFoundError):
- with pytest.raises(FileNotFoundError):
- await _read_annotations_async(fake_path)