feat: eliminate AgentRegistry and implement direct agent embedding

- BREAKING: ADKAgent constructor now requires adk_agent parameter instead of agent_id
- BREAKING: Removed AgentRegistry dependency - agents directly embedded in middleware instances
- BREAKING: Removed agent_id parameter from ADKAgent.run() method
- BREAKING: AgentRegistry class removed from public API
- ARCHITECTURE: Eliminated confusing indirection where endpoint agent didn't determine execution
- ARCHITECTURE: Each ADKAgent instance now directly holds its ADK agent instance
- ARCHITECTURE: Simplified method signatures and removed agent lookup overhead
- FIXED: All 271 tests now pass with new simplified architecture
- EXAMPLES: Updated examples to demonstrate direct agent embedding pattern
- TESTS: Updated all test fixtures to work with new agent embedding pattern

🤖 Generated with [Claude Code](https://claude.ai/code)

Co-Authored-By: Claude <[email protected]>

Author: mefogle

typescript-sdk/integrations/adk-middleware/CHANGELOG.md

@@ -7,15 +7,40 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 
 ## [Unreleased]
 
+## [0.5.0] - 2025-01-08
+
+### Breaking Changes
+- **BREAKING**: ADKAgent constructor now requires `adk_agent` parameter instead of `agent_id` for direct agent embedding
+- **BREAKING**: Removed AgentRegistry dependency - agents are now directly embedded in middleware instances
+- **BREAKING**: Removed `agent_id` parameter from `ADKAgent.run()` method
+- **BREAKING**: Endpoint registration no longer extracts agent_id from URL path
+- **BREAKING**: AgentRegistry class removed from public API
+
+### Architecture Improvements
+- **ARCHITECTURE**: Eliminated AgentRegistry entirely - simplified architecture by embedding ADK agents directly
+- **ARCHITECTURE**: Cleaned up agent registration/instantiation redundancy (issue #24)
+- **ARCHITECTURE**: Removed confusing indirection where endpoint agent didn't determine execution
+- **ARCHITECTURE**: Each ADKAgent instance now directly holds its ADK agent instance
+- **ARCHITECTURE**: Simplified method signatures and removed agent lookup overhead
+
+### Fixed
+- **FIXED**: All 271 tests now pass with new simplified architecture
+- **EXAMPLES**: Updated examples to demonstrate direct agent embedding pattern
+- **TESTS**: Updated all test fixtures to work with new agent embedding pattern
+
 ### Added
 - **NEW**: SystemMessage support for ADK agents (issue #22) - SystemMessages as first message are now appended to agent instructions
 - **NEW**: Comprehensive tests for SystemMessage functionality including edge cases
+- **NEW**: Long running tools can be defined in backend side as well
+- **NEW**: Predictive state demo is added in dojo App
 
 ### Fixed  
 - **FIXED**: Race condition in tool result processing causing "No pending tool calls found" warnings
 - **FIXED**: Tool call removal now happens after pending check to prevent race conditions
 - **IMPROVED**: Better handling of empty tool result content with graceful JSON parsing fallback
 - **FIXED**: Pending tool call state management now uses SessionManager methods (issue #25)
+- **FIXED**: Pending tools issue for normal backend tools is now fixed (issue #32)
+- **FIXED**: TestEventTranslatorComprehensive unit test cases fixed
 
 ### Enhanced
 - **LOGGING**: Added debug logging for tool result processing to aid in troubleshooting

typescript-sdk/integrations/adk-middleware/examples/complete_setup.py

@@ -25,7 +25,7 @@
 # from adk_agent import ADKAgent
 # from agent_registry import AgentRegistry
 # from endpoint import add_adk_fastapi_endpoint
-from adk_middleware import ADKAgent, AgentRegistry, add_adk_fastapi_endpoint
+from adk_middleware import ADKAgent, add_adk_fastapi_endpoint
 # Import Google ADK components
 from google.adk.agents import Agent
 from google.adk import tools as adk_tools
@@ -74,32 +74,22 @@ async def setup_and_run():
         tools=[adk_tools.preload_memory_tool.PreloadMemoryTool()]
     )
 
-    # Step 3: Register agents
-    print("📝 Registering agents...")
-    registry = AgentRegistry.get_instance()
-    
-    # Register with specific IDs that AG-UI clients can reference
-    registry.register_agent("assistant", assistant)
-    
-    # Try to import and register haiku generator agent
+    # Try to import haiku generator agent
     print("🎋 Attempting to import haiku generator agent...")
+    haiku_generator_agent = None
     try:
         from tool_based_generative_ui.agent import haiku_generator_agent
         print(f"   ✅ Successfully imported haiku_generator_agent")
         print(f"   Type: {type(haiku_generator_agent)}")
         print(f"   Name: {getattr(haiku_generator_agent, 'name', 'NO NAME')}")
-        registry.register_agent('adk-tool-based-generative-ui', haiku_generator_agent)
-        print(f"   ✅ Registered as 'adk-tool-based-generative-ui'")
+        print(f"   ✅ Available for use")
     except Exception as e:
         print(f"   ❌ Failed to import haiku_generator_agent: {e}")
 
-    # Set default agent
-    registry.set_default_agent(assistant)
-    
-    # List all registered agents
-    print("\n📋 Currently registered agents:")
-    for agent_id in registry.list_registered_agents():
-        print(f"   - {agent_id}")
+    print(f"\n📋 Available agents:")
+    print(f"   - assistant: {assistant.name}")
+    if haiku_generator_agent:
+        print(f"   - haiku_generator: {haiku_generator_agent.name}")
 
 
     # Step 4: Configure ADK middleware
@@ -127,14 +117,26 @@ def extract_app_name(input_data):
                 return ctx.value
         return "default_app"
 
-    adk_agent = ADKAgent(
+    # Create ADKAgent instances for different agents
+    assistant_adk_agent = ADKAgent(
+        adk_agent=assistant,
         app_name_extractor=extract_app_name,
         user_id_extractor=extract_user_id,
         use_in_memory_services=True,
         memory_service=shared_memory_service,  # Use the same memory service as the ADK agent
         # Defaults: 1200s timeout (20 min), 300s cleanup (5 min)
     )
 
+    haiku_adk_agent = None
+    if haiku_generator_agent:
+        haiku_adk_agent = ADKAgent(
+            adk_agent=haiku_generator_agent,
+            app_name_extractor=extract_app_name,
+            user_id_extractor=extract_user_id,
+            use_in_memory_services=True,
+            memory_service=shared_memory_service,
+        )
+    
     # Step 5: Create FastAPI app
     print("🌐 Creating FastAPI app...")
     app = FastAPI(
@@ -153,52 +155,60 @@ def extract_app_name(input_data):
 
 
     # Step 6: Add endpoints
-    # Main chat endpoint
-    add_adk_fastapi_endpoint(app, adk_agent, path="/chat")
-    
-    # Add haiku generator endpoint
-    add_adk_fastapi_endpoint(app, adk_agent, path="/adk-tool-based-generative-ui")
-    print("   ✅ Added endpoint: /adk-tool-based-generative-ui")
-    
-    # Agent-specific endpoints (optional)
-    # This allows clients to specify which agent to use via the URL
-    # add_adk_fastapi_endpoint(app, adk_agent, path="/agents/assistant")
-    # add_adk_fastapi_endpoint(app, adk_agent, path="/agents/code-helper")
+    # Each endpoint uses its specific ADKAgent instance
+    add_adk_fastapi_endpoint(app, assistant_adk_agent, path="/chat")
+    
+    # Add haiku generator endpoint if available
+    if haiku_adk_agent:
+        add_adk_fastapi_endpoint(app, haiku_adk_agent, path="/adk-tool-based-generative-ui")
+        print("   ✅ Added endpoint: /adk-tool-based-generative-ui")
+    else:
+        print("   ❌ Skipped haiku endpoint - agent not available")
+    
+    # Agent-specific endpoints (optional) - each would use its own ADKAgent instance
+    # assistant_adk_agent = ADKAgent(adk_agent=assistant, ...)
+    # add_adk_fastapi_endpoint(app, assistant_adk_agent, path="/agents/assistant")
+    # code_helper_adk_agent = ADKAgent(adk_agent=code_helper, ...)
+    # add_adk_fastapi_endpoint(app, code_helper_adk_agent, path="/agents/code-helper")
 
     @app.get("/")
     async def root():
-        registry = AgentRegistry.get_instance()
+        available_agents = ["assistant"]
+        endpoints = {"chat": "/chat", "docs": "/docs", "health": "/health"}
+        if haiku_generator_agent:
+            available_agents.append("haiku-generator")
+            endpoints["adk-tool-based-generative-ui"] = "/adk-tool-based-generative-ui"
+        
         return {
             "service": "ADK-AG-UI Integration",
             "version": "0.1.0",
             "agents": {
                 "default": "assistant",
-                "available": registry.list_registered_agents()
+                "available": available_agents
             },
-            "endpoints": {
-                "chat": "/chat",
-                "adk-tool-based-generative-ui": "/adk-tool-based-generative-ui",
-                "docs": "/docs",
-                "health": "/health"
-            }
+            "endpoints": endpoints
         }
 
     @app.get("/health")
     async def health():
-        registry = AgentRegistry.get_instance()
+        agent_count = 1  # assistant
+        if haiku_generator_agent:
+            agent_count += 1
         return {
             "status": "healthy",
-            "agents_registered": len(registry._agents),
-            "default_agent": registry._default_agent_id
+            "agents_available": agent_count,
+            "default_agent": "assistant"
         }
 
     @app.get("/agents")
     async def list_agents():
         """List available agents."""
-        registry = AgentRegistry.get_instance()
+        available_agents = ["assistant"]
+        if haiku_generator_agent:
+            available_agents.append("haiku-generator")
         return {
-            "agents": list(registry._agents.keys()),
-            "default": registry._default_agent_id
+            "agents": available_agents,
+            "default": "assistant"
         }
 
 

typescript-sdk/integrations/adk-middleware/examples/fastapi_server.py

@@ -12,6 +12,7 @@
 from .tool_based_generative_ui.agent import haiku_generator_agent
 from .human_in_the_loop.agent import human_in_loop_agent
 from .shared_state.agent import shared_state_agent
+from .predictive_state_updates.agent import predictive_state_updates_agent
 
 # Basic logging configuration
 logging.basicConfig(level=logging.INFO, format='%(asctime)s - %(name)s - %(levelname)s - %(message)s')
@@ -22,48 +23,52 @@
     # from src.agent_registry import AgentRegistry
     # from src.endpoint import add_adk_fastapi_endpoint
 
-    from adk_middleware import ADKAgent, AgentRegistry, add_adk_fastapi_endpoint
+    from adk_middleware import ADKAgent, add_adk_fastapi_endpoint
     from google.adk.agents import LlmAgent
     from google.adk import tools as adk_tools
 
-    # Set up the agent registry
-    registry = AgentRegistry.get_instance()
-    
     # Create a sample ADK agent (this would be your actual agent)
     sample_agent = LlmAgent(
         name="assistant",
         model="gemini-2.0-flash",
-        instruction="You are a helpful assistant.",
+        instruction="You are a helpful assistant. Help users by answering their questions and assisting with their needs.",
         tools=[adk_tools.preload_memory_tool.PreloadMemoryTool()]
     )
-    # Register the agent
-    registry.set_default_agent(sample_agent)
-    registry.register_agent('adk-tool-based-generative-ui', haiku_generator_agent)
-    registry.register_agent('adk-human-in-loop-agent', human_in_loop_agent)
-    registry.register_agent('adk-shared-state-agent', shared_state_agent)
-    # Create ADK middleware agent
-    adk_agent = ADKAgent(
+    # Create ADK middleware agent instances with direct agent references
+    chat_agent = ADKAgent(
+        adk_agent=sample_agent,
         app_name="demo_app",
         user_id="demo_user",
         session_timeout_seconds=3600,
         use_in_memory_services=True
     )
 
     adk_agent_haiku_generator = ADKAgent(
+        adk_agent=haiku_generator_agent,
         app_name="demo_app",
         user_id="demo_user",
         session_timeout_seconds=3600,
         use_in_memory_services=True
     )
 
     adk_human_in_loop_agent = ADKAgent(
+        adk_agent=human_in_loop_agent,
         app_name="demo_app",
         user_id="demo_user",
         session_timeout_seconds=3600,
         use_in_memory_services=True
     )
 
     adk_shared_state_agent = ADKAgent(
+        adk_agent=shared_state_agent,
+        app_name="demo_app",
+        user_id="demo_user",
+        session_timeout_seconds=3600,
+        use_in_memory_services=True
+    )
+    
+    adk_predictive_state_agent = ADKAgent(
+        adk_agent=predictive_state_updates_agent,
         app_name="demo_app",
         user_id="demo_user",
         session_timeout_seconds=3600,
@@ -74,10 +79,11 @@
     app = FastAPI(title="ADK Middleware Demo")
 
     # Add the ADK endpoint
-    add_adk_fastapi_endpoint(app, adk_agent, path="/chat")
+    add_adk_fastapi_endpoint(app, chat_agent, path="/chat")
     add_adk_fastapi_endpoint(app, adk_agent_haiku_generator, path="/adk-tool-based-generative-ui")
     add_adk_fastapi_endpoint(app, adk_human_in_loop_agent, path="/adk-human-in-loop-agent")
     add_adk_fastapi_endpoint(app, adk_shared_state_agent, path="/adk-shared-state-agent")
+    add_adk_fastapi_endpoint(app, adk_predictive_state_agent, path="/adk-predictive-state-agent")
 
     @app.get("/")
     async def root():

typescript-sdk/integrations/adk-middleware/src/adk_middleware/__init__.py

@@ -6,11 +6,10 @@
 """
 
 from .adk_agent import ADKAgent
-from .agent_registry import AgentRegistry
 from .event_translator import EventTranslator
 from .session_manager import SessionManager
 from .endpoint import add_adk_fastapi_endpoint, create_adk_app
 
-__all__ = ['ADKAgent', 'AgentRegistry', 'add_adk_fastapi_endpoint', 'create_adk_app','EventTranslator','SessionManager']
+__all__ = ['ADKAgent', 'add_adk_fastapi_endpoint', 'create_adk_app', 'EventTranslator', 'SessionManager']
 
 __version__ = "0.1.0"