- {total_requests}
+ {total_requests}
Total API Calls
-
+ {last_triage_decision}
Last Triage Split
- {avg_triage_latency_ms:.1f} ms
+ {avg_triage_latency_ms:.1f} ms
Avg Triage Time
- {avg_proxy_latency_ms:.1f} ms
+ {avg_proxy_latency_ms:.1f} ms
Avg Proxy Time
- {cache_hits}
+ {cache_hits}
Triage Cache Hits
{src_badge('ROUTER', '#818cf8')} Triage Routing Split
- {tier_table_html}
+
+ {tier_table_html}
+
-
+
Active Tool Split %
- {pie_legend_html} +
+ {pie_legend_html}
+
-
{p_tokens:,}
+ {p_tokens:,}
Prompt Tokens
-
{c_tokens:,}
+ {c_tokens:,}
Completion Tokens
-
{t_tokens:,}
+ {t_tokens:,}
Combined Total
-
@@ -3055,7 +3099,7 @@ async def get_dashboard():
{src_badge('GOOSE', '#fbbf24')} Live Tool Token Meters
Token meters per extension tool
-
+
-
+
@@ -3045,7 +3089,7 @@ async def get_dashboard():
{routing_legend_html if routing_legend_html else "
No routing data yet
"}
Per-model usage, token consumption & cost are tracked with full trace detail in Langfuse.
- Open Langfuse Observability β + Open Langfuse Observability β
+
@@ -3066,7 +3110,7 @@ async def get_dashboard():
{src_badge('ROUTER', '#818cf8')} Request Timeline
Recent completions cascade
-
{tool_tokens_html}
+
@@ -3080,7 +3124,7 @@ async def get_dashboard():
{src_badge('INTELLECT', '#34d399')} Frontier Free Model
agentic index score
-
{timeline_html}
+
{best_free_model['name']}
β‘ {best_free_model['score']:.1f}
@@ -3110,9 +3154,9 @@ async def get_dashboard():
@@ -3120,9 +3164,9 @@ async def get_dashboard():
@@ -3130,9 +3174,9 @@ async def get_dashboard():
@@ -3140,9 +3184,9 @@ async def get_dashboard():
@@ -3152,16 +3196,20 @@ async def get_dashboard():
LiteLLM Proxy
- {LITELLM_PORT}
+ :4000
-
+
{'Online' if litellm_status else 'Offline'}
Valkey Cache
- :{VALKEY_PORT}
+ :6379
-
+
{'Online' if valkey_status else 'Offline'}
Llama-Server
- {LLAMA_SERVER_PORT}
+ :8080
-
+
{'Online' if llama_server_status else 'Offline'}
Langfuse Traces
- {LANGFUSE_PORT}
+ :3001
-
+
{'Online' if langfuse_status else 'Offline'}
{src_badge('LLAMA.CPP', '#fb923c')} Engine Metrics
- build {llamacpp['build']}
+ build {data['llamacpp_build']}
+
+
+ {llamacpp_models_html}
+
+
+ {llamacpp_slots_html}
- {llamacpp_models_html}
- {llamacpp_slots_html}
{src_badge('GOOSE', '#fbbf24')} Session Directory
-
+
@@ -3177,15 +3225,15 @@ async def get_dashboard():
{goose_html}
-
+
{src_badge('LANGFUSE', '#e879f9')} Observability UI
β
-
+
{src_badge('LITELLM', '#34d399')} Admin UI
β
-
+
{src_badge('LLAMA.CPP', '#fb923c')} Server Router UI
β
@@ -3303,5 +3351,6 @@ async def save_annotations(payload: Dict[str, AnnotationItem]):
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/test_memory_mcp.py b/router/test_memory_mcp.py
new file mode 100644
index 00000000..49dc3355
--- /dev/null
+++ b/router/test_memory_mcp.py
@@ -0,0 +1,113 @@
+import pytest
+import time
+import re
+import sys
+import json
+from pathlib import Path
+sys.path.insert(0, str(Path(__file__).resolve().parent))
+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."""
+ 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}"
+ parts = key.split(":")
+
+ assert key.startswith(f"{PREFIX}:{SCOPE_GLOBAL}:{category}::")
+
+ # Extract timestamp and hash part
+ # Format is memory:global:test_cat::1717612345:a1b2c3d4
+ match = re.match(rf"^{PREFIX}:{SCOPE_GLOBAL}:{category}::(\d+):([a-z0-9x]+)$", 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) <= 12
+
+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-z0-9x]+)$", 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) <= 12
+
+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": []}
diff --git a/test_compute_free_model_score.py b/test_compute_free_model_score.py
new file mode 100644
index 00000000..2fab732c
--- /dev/null
+++ b/test_compute_free_model_score.py
@@ -0,0 +1,44 @@
+import pytest
+from unittest.mock import patch, mock_open
+import json
+
+from router import main as router_main
+from router.main import compute_free_model_score
+
+@pytest.fixture(autouse=True)
+def reset_cache():
+ """Reset the global cache state before each test."""
+ router_main._AA_SCORES_CACHE = {}
+ router_main._AA_SCORES_LOADED = False
+ yield
+ router_main._AA_SCORES_CACHE = {}
+ router_main._AA_SCORES_LOADED = False
+
+def test_compute_free_model_score_known_model():
+ """Test when the model id exists in the cache."""
+ mock_data = json.dumps({"scores": {"model-a": 85.5}})
+ with patch("builtins.open", mock_open(read_data=mock_data)):
+ score = compute_free_model_score({"id": "model-a"})
+ assert score == 85.5
+
+def test_compute_free_model_score_unknown_model():
+ """Test when the model id is not in the cache."""
+ mock_data = json.dumps({"scores": {"model-a": 85.5}})
+ with patch("builtins.open", mock_open(read_data=mock_data)):
+ score = compute_free_model_score({"id": "model-b"})
+ assert score == 25.0
+
+def test_compute_free_model_score_missing_id():
+ """Test when the model dictionary is missing an 'id'."""
+ mock_data = json.dumps({"scores": {"model-a": 85.5}})
+ with patch("builtins.open", mock_open(read_data=mock_data)):
+ score = compute_free_model_score({"name": "just a name"})
+ assert score == 25.0
+
+def test_compute_free_model_score_file_not_found():
+ """Test fallback when the aa_scores.json file is missing or fails to load."""
+ with patch("builtins.open", side_effect=FileNotFoundError):
+ score = compute_free_model_score({"id": "model-a"})
+ assert score == 25.0
+ assert router_main._AA_SCORES_LOADED is True
+ assert router_main._AA_SCORES_CACHE == {}
diff --git a/test_memory_mcp.py b/test_memory_mcp.py
new file mode 100644
index 00000000..23f68bcc
--- /dev/null
+++ b/test_memory_mcp.py
@@ -0,0 +1,75 @@
+#!/usr/bin/env python3
+import json
+import pytest
+from router.memory_mcp import _memory_entry
+
+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