fix(test): integrate configurable endpoints with test

test(test-apis): fixed basic e2e test for test-apis

Signed-off-by: NathanD <relvox@gmail.com>

Author: Relvox

src/parlant/api/app.py

@@ -59,7 +59,6 @@
 from parlant.core.engines.alpha.tool_calling.tool_caller import ToolCaller
 from parlant.core.evaluations import EvaluationStore, EvaluationListener
 from parlant.core.journeys import JourneyStore
-from parlant.core.tools import LocalToolService
 from parlant.core.utterances import UtteranceStore
 from parlant.core.relationships import RelationshipStore
 from parlant.core.guidelines import GuidelineStore
@@ -449,24 +448,29 @@ async def configure_test_router(
 ) -> AsyncIterator[FastAPI]:
     test_router_guideline_matching = (
         guideline_matcher_test_api.create_test_guideline_matching_router(
-            guideline_matcher=container[GuidelineMatcher],
             agent_store=container[AgentStore],
             customer_store=container[CustomerStore],
             context_variable_store=container[ContextVariableStore],
-            guideline_store=container[GuidelineStore],
-            glossary_store=container[GlossaryStore],
             session_store=container[SessionStore],
+            glossary_store=container[GlossaryStore],
+            guideline_store=container[GuidelineStore],
+            guideline_matcher=container[GuidelineMatcher],
         )
     )
     app.include_router(test_router_guideline_matching, prefix="/test/alpha/guideline-matching")
 
     test_router_tool_call_inference = (
         tool_call_inference_test_api.create_test_tool_call_inference_router(
-            tool_caller=container[ToolCaller],
             agent_store=container[AgentStore],
             customer_store=container[CustomerStore],
+            context_variable_store=container[ContextVariableStore],
             session_store=container[SessionStore],
-            tool_service=container[LocalToolService],
+            glossary_store=container[GlossaryStore],
+            guideline_store=container[GuidelineStore],
+            service_registry=container[ServiceRegistry],
+            journey_store=container[JourneyStore],
+            tool_caller=container[ToolCaller],
+            logger=container[Logger],
         )
     )
     app.include_router(test_router_tool_call_inference, prefix="/test/alpha/tool-call-inference")

src/parlant/api/guideline_matcher_test_api.py

@@ -81,20 +81,20 @@ class GuidelineMatchingParamsDTO(DefaultBaseModel):
     agent_id: AgentIdPath
     customer_id: CustomerIdPath
     context_variables: Sequence[ContextVariableIdPath]
-    events: Sequence[EventIdPath]
+    interaction_history: Sequence[EventIdPath]
     terms: Sequence[TermIdPath]
     staged_events: Sequence[EmittedEventDTO]
     guidelines: Sequence[GuidelineIdPath]
 
 
 def create_test_guideline_matching_router(
-    guideline_matcher: GuidelineMatcher,
     agent_store: AgentStore,
     customer_store: CustomerStore,
     context_variable_store: ContextVariableStore,
-    guideline_store: GuidelineStore,
-    glossary_store: GlossaryStore,
     session_store: SessionStore,
+    glossary_store: GlossaryStore,
+    guideline_store: GuidelineStore,
+    guideline_matcher: GuidelineMatcher,
 ) -> APIRouter:
     test_router = APIRouter()
 
@@ -135,15 +135,11 @@ async def match_guidelines(
 
         session_id = sessions[0].id
         events: list[Event] = []
-        for event_id in params.events:
+        for event_id in params.interaction_history:
             event = await session_store.read_event(session_id, event_id)
             events.append(event)
 
-        terms: list[Term] = []
-        for term_id in params.terms:
-            if glossary_store:
-                term = await glossary_store.read_term(term_id)
-                terms.append(term)
+        terms: list[Term] = [await glossary_store.read_term(term_id) for term_id in params.terms]
 
         staged_events: list[EmittedEvent] = []
         for staged_event in params.staged_events:
@@ -163,6 +159,7 @@ async def match_guidelines(
 
         guideline_matching_result = await guideline_matcher.match_guidelines(
             agent=agent,
+            session=sessions[0],
             customer=customer,
             context_variables=context_variables,
             interaction_history=events,
@@ -192,8 +189,6 @@ async def match_guidelines(
                     score=match.score,
                     rationale=match.rationale,
                     guideline_previously_applied=match.guideline_previously_applied,
-                    guideline_is_continuous=match.guideline_is_continuous,
-                    should_reapply=match.should_reapply,
                 )
                 for match in batch
             ]

src/parlant/api/tool_call_inference_test_api.py

@@ -17,18 +17,37 @@
 
 from parlant.api.agents import AgentIdPath
 from parlant.api.common import JSONSerializableDTO, ToolNameField, apigen_config
+from parlant.api.context_variables import ContextVariableIdPath
 from parlant.api.customers import CustomerIdPath
-from parlant.api.sessions import EventCorrelationIdField, EventIdPath, EventKindDTO, EventSourceDTO
+from parlant.api.glossary import TermIdPath
+from parlant.api.journeys import JourneyIdPath
+from parlant.api.sessions import (
+    EventCorrelationIdField,
+    EventIdPath,
+    EventKindDTO,
+    EventSourceDTO,
+)
 from parlant.core.agents import AgentStore
 from parlant.core.common import DefaultBaseModel
-from parlant.core.context_variables import ContextVariable, ContextVariableValue
+from parlant.core.context_variables import (
+    ContextVariable,
+    ContextVariableStore,
+    ContextVariableValue,
+)
 from parlant.core.customers import CustomerStore
 from parlant.core.emissions import EmittedEvent
-from parlant.core.engines.alpha.guideline_matching.guideline_match import GuidelineMatch
+from parlant.core.engines.alpha.guideline_matching.guideline_match import (
+    GuidelineMatch,
+    GuidelineMatchDTO,
+)
 from parlant.core.engines.alpha.tool_calling.tool_caller import ToolCall, ToolCaller
-from parlant.core.glossary import Term
+from parlant.core.glossary import GlossaryStore, Term
+from parlant.core.guidelines import GuidelineStore
+from parlant.core.journeys import Journey, JourneyStore
+from parlant.core.loggers import Logger
 from parlant.core.sessions import Event, EventKind, EventSource, SessionStore
-from parlant.core.tools import Tool, ToolContext, ToolId, ToolService
+from parlant.core.tools import Tool, ToolContext, ToolId
+from parlant.core.services.tools.service_registry import ServiceRegistry
 
 
 API_GROUP = "engine_test"
@@ -69,17 +88,39 @@ class EmittedEventDTO(DefaultBaseModel):
 class ToolCallInferenceParamsDTO(DefaultBaseModel):
     agent_id: AgentIdPath
     customer_id: CustomerIdPath
-    events: Sequence[EventIdPath]
+    context_variables: Sequence[ContextVariableIdPath]
+    interaction_history: Sequence[EventIdPath]
+    terms: Sequence[TermIdPath]
+    ordinary_guideline_matches: Sequence[GuidelineMatchDTO]
+    tool_enabled_guideline_matches: Sequence[GuidelineMatchDTO]
+    journeys: Sequence[JourneyIdPath]
     staged_events: Sequence[EmittedEventDTO]
     available_tools: Sequence[ToolNameField]
 
 
+async def _convert_guideline_match(
+    guideline_store: GuidelineStore,
+    dto: GuidelineMatchDTO,
+) -> GuidelineMatch:
+    return GuidelineMatch(
+        await guideline_store.read_guideline(dto.guideline_id),
+        dto.score,
+        dto.rationale,
+        dto.guideline_previously_applied,
+    )
+
+
 def create_test_tool_call_inference_router(
-    tool_caller: ToolCaller,
     agent_store: AgentStore,
     customer_store: CustomerStore,
+    context_variable_store: ContextVariableStore,
     session_store: SessionStore,
-    tool_service: ToolService,
+    glossary_store: GlossaryStore,
+    guideline_store: GuidelineStore,
+    service_registry: ServiceRegistry,
+    journey_store: JourneyStore,
+    tool_caller: ToolCaller,
+    logger: Logger,
 ) -> APIRouter:
     test_router = APIRouter()
 
@@ -104,6 +145,13 @@ async def infer_tool_calls(
         agent = await agent_store.read_agent(params.agent_id)
         customer = await customer_store.read_customer(params.customer_id)
 
+        context_variables: list[tuple[ContextVariable, ContextVariableValue]] = []
+        for context_variable_id in params.context_variables:
+            context_variable = await context_variable_store.read_variable(context_variable_id)
+            context_variable_values = await context_variable_store.list_values(context_variable_id)
+            for _, context_variable_value in context_variable_values:
+                context_variables.append((context_variable, context_variable_value))
+
         sessions = await session_store.list_sessions(params.agent_id, params.customer_id)
         if len(sessions) == 0:
             raise HTTPException(
@@ -113,16 +161,16 @@ async def infer_tool_calls(
 
         session_id = sessions[0].id
         events: list[Event] = []
-        for event_id in params.events:
+        for event_id in params.interaction_history:
             event = await session_store.read_event(session_id, event_id)
             events.append(event)
 
         staged_events: list[EmittedEvent] = []
         for staged_event in params.staged_events:
             staged_events.append(
                 EmittedEvent(
-                    source=EventSource(staged_event.source),
-                    kind=EventKind(staged_event.kind),
+                    source=EventSource(staged_event.source.value),
+                    kind=EventKind(staged_event.kind.value),
                     correlation_id=staged_event.correlation_id,
                     data=staged_event.data,
                 )
@@ -133,28 +181,49 @@ async def infer_tool_calls(
         for tool_id_str in params.available_tools:
             tool_id = ToolId.from_string(tool_id_str)
             tool_ids.append(tool_id)
-            tool = await tool_service.read_tool(tool_id.tool_name)
-            available_tools.append(tool)
 
-        context_variables: list[tuple[ContextVariable, ContextVariableValue]] = []
-        terms: list[Term] = []
-        ordinary_guideline_matches: list[GuidelineMatch] = []
-        tool_enabled_guideline_matches: dict[GuidelineMatch, list[ToolId]] = {}
+            try:
+                tool_service = await service_registry.read_tool_service(tool_id.service_name)
+                tool = await tool_service.read_tool(tool_id.tool_name)
+                available_tools.append(tool)
+            except Exception as e:
+                raise HTTPException(
+                    status_code=status.HTTP_404_NOT_FOUND,
+                    detail=f"Tool '{tool_id.tool_name}' not found in service '{tool_id.service_name}': {str(e)}",
+                )
+
+        terms: list[Term] = [await glossary_store.read_term(term_id) for term_id in params.terms]
+
+        ordinary_guideline_matches: list[GuidelineMatch] = [
+            await _convert_guideline_match(guideline_store, match_dto)
+            for match_dto in params.ordinary_guideline_matches
+        ]
+
+        tool_enabled_guideline_matches: dict[GuidelineMatch, list[ToolId]] = {
+            await _convert_guideline_match(guideline_store, match_dto): [
+                ToolId.from_string(id) for id in (match_dto.associated_tool_ids or [])
+            ]
+            for match_dto in params.tool_enabled_guideline_matches
+        }
 
         tool_context = ToolContext(
             agent_id=agent.id,
             customer_id=customer.id,
             session_id=session_id,
         )
 
+        journeys: list[Journey] = [
+            await journey_store.read_journey(journey_id) for journey_id in params.journeys
+        ]
+
         tool_call_inference_result = await tool_caller.infer_tool_calls(
             agent=agent,
             context_variables=context_variables,
             interaction_history=events,
             terms=terms,
             ordinary_guideline_matches=ordinary_guideline_matches,
             tool_enabled_guideline_matches=tool_enabled_guideline_matches,
-            journeys=[],
+            journeys=journeys,
             staged_events=staged_events,
             tool_context=tool_context,
         )

src/parlant/core/engines/alpha/guideline_matching/guideline_match.py

@@ -16,7 +16,14 @@
 
 from dataclasses import dataclass
 from enum import Enum
+from typing import Annotated, Optional, TypeAlias
 
+from pydantic import Field
+
+
+from parlant.api.common import GuidelineIdField
+from parlant.api.sessions import GuidelineMatchRationaleField, GuidelineMatchScoreField, ToolIdField
+from parlant.core.common import DefaultBaseModel
 from parlant.core.guidelines import Guideline
 
 
@@ -39,3 +46,56 @@ class GuidelineMatch:
 class AnalyzedGuideline:
     guideline: Guideline
     is_previously_applied: bool
+
+
+GuidelinePreviouslyAppliedField: TypeAlias = Annotated[
+    PreviouslyAppliedType,
+    Field(
+        default=PreviouslyAppliedType.NO,
+        description="Status of the guideline's previous application.",
+        examples=[
+            PreviouslyAppliedType.NO,
+            PreviouslyAppliedType.PARTIALLY,
+            PreviouslyAppliedType.FULLY,
+            PreviouslyAppliedType.IRRELEVANT,
+        ],
+    ),
+]
+
+GuidelineIsContinuousField: TypeAlias = Annotated[
+    bool,
+    Field(
+        default=False,
+        description="Whether the guideline is continuous.",
+        examples=[True, False],
+    ),
+]
+
+GuidelineShouldReapplyField: TypeAlias = Annotated[
+    bool,
+    Field(
+        default=False,
+        description="Whether the guideline should be reapplied.",
+        examples=[True, False],
+    ),
+]
+
+guideline_match_dto_example = {
+    "guideline_id": "123xyz",
+    "score": "9",
+    "rationale": "customer asks for weather today",
+    "guideline_previously_applied": "no",
+    "guideline_is_continuous": "False",
+    "should_reapply": "False",
+}
+
+
+class GuidelineMatchDTO(
+    DefaultBaseModel,
+    json_schema_extra={"example": guideline_match_dto_example},
+):
+    guideline_id: GuidelineIdField
+    score: GuidelineMatchScoreField
+    rationale: GuidelineMatchRationaleField
+    guideline_previously_applied: GuidelinePreviouslyAppliedField
+    associated_tool_ids: Optional[list[ToolIdField]] = None