refactored: to utilise the google adk and production grade agent

app/workflows/gcp_architecture_graph.py

@@ -6,7 +6,7 @@ from langgraph.graph import END, START, StateGraph
 from langgraph.graph.state import CompiledStateGraph
 
 from app.config import get_settings
-from app.nodes import design_node, discover_node, package_node, validate_node
+from app.nodes import design_node, discover_node, package_node, source_discover_node, validate_node
 from app.skills.loader import SkillLoader
 from app.states.state import GCPArchitectureState
 
@@ -14,7 +14,7 @@ logger = logging.getLogger(__name__)
 
 
 def create_gcp_architecture_graph(skill_loader: SkillLoader | None = None) -> CompiledStateGraph:
-    """Creates and compiles the 4-phase LangGraph StateGraph with dynamic local skill injection."""
+    """Creates and compiles the LangGraph StateGraph with dynamic local skill injection."""
     if skill_loader is None:
         settings = get_settings()
         skill_loader = SkillLoader(settings.SKILLS_DIR)
@@ -23,6 +23,9 @@ def create_gcp_architecture_graph(skill_loader: SkillLoader | None = None) -> Co
     builder = StateGraph(GCPArchitectureState)
 
     # Wrap nodes with skill loader injection
+    def run_source_discover(state: GCPArchitectureState) -> dict[str, Any]:
+        return source_discover_node(state, skill_loader)
+
     def run_discover(state: GCPArchitectureState) -> dict[str, Any]:
         return discover_node(state, skill_loader)
 
@@ -36,13 +39,15 @@ def create_gcp_architecture_graph(skill_loader: SkillLoader | None = None) -> Co
         return package_node(state, skill_loader)
 
     # Add graph nodes
+    builder.add_node("source_discover", run_source_discover)
     builder.add_node("discover", run_discover)
     builder.add_node("design", run_design)
     builder.add_node("validate", run_validate)
     builder.add_node("package", run_package)
 
     # Add sequential workflow edges
-    builder.add_edge(START, "discover")
+    builder.add_edge(START, "source_discover")
+    builder.add_edge("source_discover", "discover")
     builder.add_edge("discover", "design")
     builder.add_edge("design", "validate")
     builder.add_edge("validate", "package")

app/workflows/routes.py

@@ -1,15 +1,19 @@
-"""Starlette REST Route Handlers for GCP Solution Architecture Agent."""
+"""Starlette REST Route Handlers for GCP Solution Architecture Agent.
+
+Powered by Google ADK runner, PostgreSQL database persistence, and multi-agent orchestration.
+"""
 
 import logging
 from typing import Any, Dict
 from starlette.requests import Request
 from starlette.responses import JSONResponse
 
+from app.adk.evaluation import ADKEvaluator
+from app.adk.runners import ADKAgentRunner
+from app.adk.sessions import PostgresSessionService
 from app.card import AGENT_CARD
 from app.config import get_settings
-from app.skills.loader import SkillLoader
 from app.tools.validation_tools import validate_repository_artifacts
-from app.workflows.gcp_architecture_graph import create_agent
 
 logger = logging.getLogger(__name__)
 
@@ -21,6 +25,8 @@ async def health_check(request: Request) -> JSONResponse:
         "status": "healthy",
         "agent": settings.AGENT_NAME,
         "version": settings.AGENT_VERSION,
+        "adk_framework": "enabled",
+        "database": "postgresql",
     })
 
 
@@ -30,7 +36,7 @@ async def get_card(request: Request) -> JSONResponse:
 
 
 async def run_workflow(request: Request) -> JSONResponse:
-    """POST /generate - Execute full 4-phase GCP Solution Architecture workflow."""
+    """POST /generate - Execute multi-agent ADK workflow with PostgreSQL persistence."""
     try:
         body = await request.json() if request.headers.get("content-type") == "application/json" else {}
     except Exception:
@@ -38,33 +44,31 @@ async def run_workflow(request: Request) -> JSONResponse:
 
     workflow_request = body.get("request", "Default event-driven HTTP architecture")
     target_dir = body.get("target_dir", ".")
+    session_id = body.get("session_id")
 
-    settings = get_settings()
-    loader = SkillLoader(settings.SKILLS_DIR)
-    loader.load_skills()
+    runner = ADKAgentRunner()
+    result = runner.run_execution(
+        session_id=session_id,
+        request_summary=workflow_request,
+        target_dir=target_dir,
+    )
 
-    agent = create_agent(loader)
-    initial_state = {
-        "workflow_request": workflow_request,
-        "target_dir": target_dir,
-        "active_skills": [],
-    }
+    return JSONResponse(result)
 
-    final_state = agent.invoke(initial_state)
+
+async def get_session_route(request: Request) -> JSONResponse:
+    """GET /sessions/{session_id} - Query session state from PostgreSQL database."""
+    session_id = request.path_params.get("session_id")
+    session_service = PostgresSessionService()
+    session = session_service.get_session(session_id)
+
+    if not session:
+        return JSONResponse({"error": f"Session {session_id} not found"}, status_code=404)
 
     return JSONResponse({
-        "status": "success",
-        "phases_completed": ["discover", "design", "validate", "package"],
-        "validation_passed": final_state.get("validation_passed", True),
-        "artifacts": {
-            "requirements_doc": final_state.get("requirements_doc"),
-            "architecture_doc": final_state.get("architecture_doc"),
-            "mermaid_diagram": final_state.get("mermaid_diagram"),
-            "terraform_code": final_state.get("terraform_code"),
-            "validation_results": final_state.get("validation_results"),
-            "solution_guide": final_state.get("solution_guide"),
-        },
-        "active_skills": final_state.get("active_skills", []),
+        "session_id": session.session_id,
+        "agent_name": session.agent_name,
+        "state": session.state,
     })
 
 
@@ -80,3 +84,6 @@ async def validate_artifacts_route(request: Request) -> JSONResponse:
 
     status_code = 200 if result.get("valid") else 400
     return JSONResponse(result, status_code=status_code)
+
+    status_code = 200 if result.get("valid") else 400
+    return JSONResponse(result, status_code=status_code)