mirror of
https://github.com/trustgraph-ai/trustgraph.git
synced 2026-04-25 00:16:23 +02:00
d35473f7f7
Introduces `workspace` as the isolation boundary for config, flows,
library, and knowledge data. Removes `user` as a schema-level field
throughout the code, API specs, and tests; workspace provides the
same separation more cleanly at the trusted flow.workspace layer
rather than through client-supplied message fields.
Design
------
- IAM tech spec (docs/tech-specs/iam.md) documents current state,
proposed auth/access model, and migration direction.
- Data ownership model (docs/tech-specs/data-ownership-model.md)
captures the workspace/collection/flow hierarchy.
Schema + messaging
------------------
- Drop `user` field from AgentRequest/Step, GraphRagQuery,
DocumentRagQuery, Triples/Graph/Document/Row EmbeddingsRequest,
Sparql/Rows/Structured QueryRequest, ToolServiceRequest.
- Keep collection/workspace routing via flow.workspace at the
service layer.
- Translators updated to not serialise/deserialise user.
API specs
---------
- OpenAPI schemas and path examples cleaned of user fields.
- Websocket async-api messages updated.
- Removed the unused parameters/User.yaml.
Services + base
---------------
- Librarian, collection manager, knowledge, config: all operations
scoped by workspace. Config client API takes workspace as first
positional arg.
- `flow.workspace` set at flow start time by the infrastructure;
no longer pass-through from clients.
- Tool service drops user-personalisation passthrough.
CLI + SDK
---------
- tg-init-workspace and workspace-aware import/export.
- All tg-* commands drop user args; accept --workspace.
- Python API/SDK (flow, socket_client, async_*, explainability,
library) drop user kwargs from every method signature.
MCP server
----------
- All tool endpoints drop user parameters; socket_manager no longer
keyed per user.
Flow service
------------
- Closure-based topic cleanup on flow stop: only delete topics
whose blueprint template was parameterised AND no remaining
live flow (across all workspaces) still resolves to that topic.
Three scopes fall out naturally from template analysis:
* {id} -> per-flow, deleted on stop
* {blueprint} -> per-blueprint, kept while any flow of the
same blueprint exists
* {workspace} -> per-workspace, kept while any flow in the
workspace exists
* literal -> global, never deleted (e.g. tg.request.librarian)
Fixes a bug where stopping a flow silently destroyed the global
librarian exchange, wedging all library operations until manual
restart.
RabbitMQ backend
----------------
- heartbeat=60, blocked_connection_timeout=300. Catches silently
dead connections (broker restart, orphaned channels, network
partitions) within ~2 heartbeat windows, so the consumer
reconnects and re-binds its queue rather than sitting forever
on a zombie connection.
Tests
-----
- Full test refresh: unit, integration, contract, provenance.
- Dropped user-field assertions and constructor kwargs across
~100 test files.
- Renamed user-collection isolation tests to workspace-collection.
214 lines
6.8 KiB
Python
214 lines
6.8 KiB
Python
"""
|
|
Unit tests for the Aggregator — tracks fan-out correlations and triggers
|
|
synthesis when all subagents complete.
|
|
"""
|
|
|
|
import time
|
|
import pytest
|
|
|
|
from trustgraph.schema import AgentRequest, AgentStep
|
|
|
|
from trustgraph.agent.orchestrator.aggregator import Aggregator
|
|
|
|
|
|
def _make_request(question="Test question",
|
|
collection="default", streaming=False,
|
|
session_id="parent-session", task_type="research",
|
|
framing="test framing", conversation_id="conv-1"):
|
|
return AgentRequest(
|
|
question=question,
|
|
collection=collection,
|
|
streaming=streaming,
|
|
session_id=session_id,
|
|
task_type=task_type,
|
|
framing=framing,
|
|
conversation_id=conversation_id,
|
|
)
|
|
|
|
|
|
class TestRegisterFanout:
|
|
|
|
def test_stores_correlation_entry(self):
|
|
agg = Aggregator()
|
|
agg.register_fanout("corr-1", "parent-1", 3)
|
|
|
|
assert "corr-1" in agg.correlations
|
|
entry = agg.correlations["corr-1"]
|
|
assert entry["parent_session_id"] == "parent-1"
|
|
assert entry["expected"] == 3
|
|
assert entry["results"] == {}
|
|
|
|
def test_stores_request_template(self):
|
|
agg = Aggregator()
|
|
template = _make_request()
|
|
agg.register_fanout("corr-1", "parent-1", 2,
|
|
request_template=template)
|
|
|
|
entry = agg.correlations["corr-1"]
|
|
assert entry["request_template"] is template
|
|
|
|
def test_records_creation_time(self):
|
|
agg = Aggregator()
|
|
before = time.time()
|
|
agg.register_fanout("corr-1", "parent-1", 2)
|
|
after = time.time()
|
|
|
|
created = agg.correlations["corr-1"]["created_at"]
|
|
assert before <= created <= after
|
|
|
|
|
|
class TestRecordCompletion:
|
|
|
|
def test_returns_false_until_all_done(self):
|
|
agg = Aggregator()
|
|
agg.register_fanout("corr-1", "parent-1", 3)
|
|
|
|
assert agg.record_completion("corr-1", "goal-a", "answer-a") is False
|
|
assert agg.record_completion("corr-1", "goal-b", "answer-b") is False
|
|
assert agg.record_completion("corr-1", "goal-c", "answer-c") is True
|
|
|
|
def test_returns_none_for_unknown_correlation(self):
|
|
agg = Aggregator()
|
|
result = agg.record_completion("unknown", "goal", "answer")
|
|
assert result is None
|
|
|
|
def test_stores_results_by_goal(self):
|
|
agg = Aggregator()
|
|
agg.register_fanout("corr-1", "parent-1", 2)
|
|
|
|
agg.record_completion("corr-1", "goal-a", "answer-a")
|
|
agg.record_completion("corr-1", "goal-b", "answer-b")
|
|
|
|
results = agg.correlations["corr-1"]["results"]
|
|
assert results["goal-a"] == "answer-a"
|
|
assert results["goal-b"] == "answer-b"
|
|
|
|
def test_single_subagent(self):
|
|
agg = Aggregator()
|
|
agg.register_fanout("corr-1", "parent-1", 1)
|
|
|
|
assert agg.record_completion("corr-1", "goal-a", "answer") is True
|
|
|
|
|
|
class TestGetOriginalRequest:
|
|
|
|
def test_peeks_without_consuming(self):
|
|
agg = Aggregator()
|
|
template = _make_request()
|
|
agg.register_fanout("corr-1", "parent-1", 2,
|
|
request_template=template)
|
|
|
|
result = agg.get_original_request("corr-1")
|
|
assert result is template
|
|
# Entry still exists
|
|
assert "corr-1" in agg.correlations
|
|
|
|
def test_returns_none_for_unknown(self):
|
|
agg = Aggregator()
|
|
assert agg.get_original_request("unknown") is None
|
|
|
|
|
|
class TestBuildSynthesisRequest:
|
|
|
|
def test_builds_correct_request(self):
|
|
agg = Aggregator()
|
|
template = _make_request(
|
|
question="Original question",
|
|
streaming=True,
|
|
task_type="risk-assessment",
|
|
framing="Assess risks",
|
|
)
|
|
agg.register_fanout("corr-1", "parent-1", 2,
|
|
request_template=template)
|
|
agg.record_completion("corr-1", "goal-a", "answer-a")
|
|
agg.record_completion("corr-1", "goal-b", "answer-b")
|
|
|
|
req = agg.build_synthesis_request(
|
|
"corr-1",
|
|
original_question="Original question",
|
|
collection="default",
|
|
)
|
|
|
|
assert req.question == "Original question"
|
|
assert req.pattern == "supervisor"
|
|
assert req.session_id == "parent-1"
|
|
assert req.correlation_id == "" # Must be empty
|
|
assert req.streaming == True
|
|
assert req.task_type == "risk-assessment"
|
|
assert req.framing == "Assess risks"
|
|
|
|
def test_synthesis_step_in_history(self):
|
|
agg = Aggregator()
|
|
template = _make_request()
|
|
agg.register_fanout("corr-1", "parent-1", 2,
|
|
request_template=template)
|
|
agg.record_completion("corr-1", "goal-a", "answer-a")
|
|
agg.record_completion("corr-1", "goal-b", "answer-b")
|
|
|
|
req = agg.build_synthesis_request(
|
|
"corr-1", "question", "default",
|
|
)
|
|
|
|
# Last history step should be the synthesis step
|
|
assert len(req.history) >= 1
|
|
synth_step = req.history[-1]
|
|
assert synth_step.step_type == "synthesise"
|
|
assert synth_step.subagent_results == {
|
|
"goal-a": "answer-a",
|
|
"goal-b": "answer-b",
|
|
}
|
|
|
|
def test_consumes_correlation_entry(self):
|
|
agg = Aggregator()
|
|
template = _make_request()
|
|
agg.register_fanout("corr-1", "parent-1", 1,
|
|
request_template=template)
|
|
agg.record_completion("corr-1", "goal-a", "answer-a")
|
|
|
|
agg.build_synthesis_request(
|
|
"corr-1", "question", "default",
|
|
)
|
|
|
|
# Entry should be removed
|
|
assert "corr-1" not in agg.correlations
|
|
|
|
def test_raises_for_unknown_correlation(self):
|
|
agg = Aggregator()
|
|
with pytest.raises(RuntimeError, match="No results"):
|
|
agg.build_synthesis_request(
|
|
"unknown", "question", "default",
|
|
)
|
|
|
|
|
|
class TestCleanupStale:
|
|
|
|
def test_removes_entries_older_than_timeout(self):
|
|
agg = Aggregator(timeout=1)
|
|
agg.register_fanout("corr-1", "parent-1", 2)
|
|
|
|
# Backdate the creation time
|
|
agg.correlations["corr-1"]["created_at"] = time.time() - 2
|
|
|
|
stale = agg.cleanup_stale()
|
|
assert "corr-1" in stale
|
|
assert "corr-1" not in agg.correlations
|
|
|
|
def test_keeps_recent_entries(self):
|
|
agg = Aggregator(timeout=300)
|
|
agg.register_fanout("corr-1", "parent-1", 2)
|
|
|
|
stale = agg.cleanup_stale()
|
|
assert stale == []
|
|
assert "corr-1" in agg.correlations
|
|
|
|
def test_mixed_stale_and_fresh(self):
|
|
agg = Aggregator(timeout=1)
|
|
agg.register_fanout("stale", "parent-1", 2)
|
|
agg.register_fanout("fresh", "parent-2", 2)
|
|
|
|
agg.correlations["stale"]["created_at"] = time.time() - 2
|
|
|
|
stale = agg.cleanup_stale()
|
|
assert "stale" in stale
|
|
assert "stale" not in agg.correlations
|
|
assert "fresh" in agg.correlations
|