idun-agent-engine 0.2.7__py3-none-any.whl → 0.3.1__py3-none-any.whl

idun_agent_engine/server/routers/agent.py

@@ -3,17 +3,18 @@
 import logging
 from typing import Annotated
 
+from ag_ui.core.types import RunAgentInput
+from ag_ui.encoder import EventEncoder
+from ag_ui_adk import ADKAgent as ADKAGUIAgent
+from copilotkit import LangGraphAGUIAgent
 from fastapi import APIRouter, Depends, HTTPException, Request, status
 from fastapi.responses import StreamingResponse
 from idun_agent_schema.engine.api import ChatRequest, ChatResponse
+from idun_agent_schema.engine.guardrails import Guardrail
 
 from idun_agent_engine.agent.base import BaseAgent
 from idun_agent_engine.server.dependencies import get_agent, get_copilotkit_agent
 
-from ag_ui.core.types import RunAgentInput
-from ag_ui.encoder import EventEncoder
-from copilotkit import LangGraphAGUIAgent
-
 logging.basicConfig(
     format="%(asctime)s %(levelname)-8s %(message)s",
     level=logging.INFO,
@@ -24,6 +25,25 @@ logger = logging.getLogger(__name__)
 agent_router = APIRouter()
 
 
+def _format_deep_agent_response(response_content: list[dict[str, str]]) -> str:
+    """Deep Research Agent responds with a list contaning a single dict: {'type': 'text', 'text': 'Your text'}."""
+    try:
+        response = response_content[0]["text"]
+        return response
+    except KeyError as k:
+        raise ValueError("Cannot parse Deep Research Agent's response") from k
+
+
+def _run_guardrails(
+    guardrails: list[Guardrail], message: dict[str, str] | str, position: str
+) -> None:
+    """Validates the request's message, by running it on given guardrails. If input is a dict -> input, else its an output guardrails."""
+    text = message["query"] if isinstance(message, dict) else message
+    for guard in guardrails:
+        if guard.position == position and not guard.validate(text):  # type: ignore[attr-defined]
+            raise HTTPException(status_code=429, detail=guard.reject_message)  # type: ignore[attr-defined]
+
+
 @agent_router.get("/config")
 async def get_config(request: Request):
     """Get the current agent configuration."""
@@ -35,21 +55,35 @@ async def get_config(request: Request):
         )
 
     config = request.app.state.engine_config.agent
-    logger.info(f"Fetched config for agent: {config}")
+    logger.info(f"Fetched config for agent: {request.app.state.engine_config}")
     return {"config": config}
 
 
 @agent_router.post("/invoke", response_model=ChatResponse)
 async def invoke(
-    request: ChatRequest,
+    chat_request: ChatRequest,
+    request: Request,
     agent: Annotated[BaseAgent, Depends(get_agent)],
 ):
     """Process a chat message with the agent without streaming."""
     try:
-        message = {"query": request.query, "session_id": request.session_id}
-        response_content = await agent.invoke(message)
+        message = {"query": chat_request.query, "session_id": chat_request.session_id}
+        guardrails = getattr(request.app.state, "guardrails", [])
+        if guardrails:
+            _run_guardrails(guardrails, message, position="input")
+        response_content = await agent.invoke(
+            {"query": message["query"], "session_id": message["session_id"]}
+        )
+        if guardrails:
+            _run_guardrails(guardrails, response_content, position="output")
+
+        if agent.name == "Deep Research Agent":
+            return ChatResponse(
+                session_id=message["session_id"],
+                response=_format_deep_agent_response(response_content),
+            )
+        return ChatResponse(session_id=message["session_id"], response=response_content)
 
-        return ChatResponse(session_id=request.session_id, response=response_content)
     except Exception as e:  # noqa: BLE001
         raise HTTPException(status_code=500, detail=str(e)) from e
 
@@ -70,27 +104,101 @@ async def stream(
     except Exception as e:  # noqa: BLE001
         raise HTTPException(status_code=500, detail=str(e)) from e
 
+
 @agent_router.post("/copilotkit/stream")
 async def copilotkit_stream(
     input_data: RunAgentInput,
     request: Request,
-    copilotkit_agent: Annotated[LangGraphAGUIAgent, Depends(get_copilotkit_agent)],
+    copilotkit_agent: Annotated[
+        LangGraphAGUIAgent | ADKAGUIAgent, Depends(get_copilotkit_agent)
+    ],
 ):
     """Process a message with the agent, streaming ag-ui events."""
-    try:
-        # Get the accept header from the request
-        accept_header = request.headers.get("accept")
-
-        # Create an event encoder to properly format SSE events
-        encoder = EventEncoder(accept=accept_header or "") # type: ignore[arg-type]
-
-        async def event_generator():
-            async for event in copilotkit_agent.run(input_data):
-                yield encoder.encode(event)
-
-        return StreamingResponse(
-            event_generator(),  # type: ignore[arg-type]
-            media_type=encoder.get_content_type()
-        )
-    except Exception as e:  # noqa: BLE001
-        raise HTTPException(status_code=500, detail=str(e)) from e
+    if isinstance(copilotkit_agent, LangGraphAGUIAgent):
+        try:
+            # Get the accept header from the request
+            accept_header = request.headers.get("accept")
+
+            # Create an event encoder to properly format SSE events
+            encoder = EventEncoder(accept=accept_header or "")  # type: ignore[arg-type]
+
+            async def event_generator():
+                async for event in copilotkit_agent.run(input_data):
+                    yield encoder.encode(event)  # type: ignore[arg-type]
+
+            return StreamingResponse(
+                event_generator(),  # type: ignore[arg-type]
+                media_type=encoder.get_content_type(),
+            )
+        except Exception as e:  # noqa: BLE001
+            raise HTTPException(status_code=500, detail=str(e)) from e
+    elif isinstance(copilotkit_agent, ADKAGUIAgent):
+        try:
+            # Get the accept header from the request
+            accept_header = request.headers.get("accept")
+            agent_id = request.url.path.lstrip("/")
+
+            # Create an event encoder to properly format SSE events
+            encoder = EventEncoder(accept=accept_header or "")
+
+            async def event_generator():
+                """Generate events from ADK agent."""
+                try:
+                    async for event in copilotkit_agent.run(input_data):
+                        try:
+                            encoded = encoder.encode(event)
+                            logger.debug(f"HTTP Response: {encoded}")
+                            yield encoded
+                        except Exception as encoding_error:
+                            # Handle encoding-specific errors
+                            logger.error(
+                                f"❌ Event encoding error: {encoding_error}",
+                                exc_info=True,
+                            )
+                            # Create a RunErrorEvent for encoding failures
+                            from ag_ui.core import EventType, RunErrorEvent
+
+                            error_event = RunErrorEvent(
+                                type=EventType.RUN_ERROR,
+                                message=f"Event encoding failed: {str(encoding_error)}",
+                                code="ENCODING_ERROR",
+                            )
+                            try:
+                                error_encoded = encoder.encode(error_event)
+                                yield error_encoded
+                            except Exception:
+                                # If we can't even encode the error event, yield a basic SSE error
+                                logger.error(
+                                    "Failed to encode error event, yielding basic SSE error"
+                                )
+                                yield 'event: error\ndata: {"error": "Event encoding failed"}\n\n'
+                            break  # Stop the stream after an encoding error
+                except Exception as agent_error:
+                    # Handle errors from ADKAgent.run() itself
+                    logger.error(f"❌ ADKAgent error: {agent_error}", exc_info=True)
+                    # ADKAgent should have yielded a RunErrorEvent, but if something went wrong
+                    # in the async generator itself, we need to handle it
+                    try:
+                        from ag_ui.core import EventType, RunErrorEvent
+
+                        error_event = RunErrorEvent(
+                            type=EventType.RUN_ERROR,
+                            message=f"Agent execution failed: {str(agent_error)}",
+                            code="AGENT_ERROR",
+                        )
+                        error_encoded = encoder.encode(error_event)
+                        yield error_encoded
+                    except Exception:
+                        # If we can't encode the error event, yield a basic SSE error
+                        logger.error(
+                            "Failed to encode agent error event, yielding basic SSE error"
+                        )
+                        yield 'event: error\ndata: {"error": "Agent execution failed"}\n\n'
+
+            return StreamingResponse(
+                event_generator(), media_type=encoder.get_content_type()
+            )
+        except Exception as e:  # noqa: BLE001
+            raise HTTPException(status_code=500, detail=str(e)) from e
+    else:
+        raise HTTPException(status_code=400, detail="Invalid agent type")

idun_agent_engine/server/routers/agui.py

@@ -0,0 +1,47 @@
+# """AGUI routes for CopilotKit integration with LangGraph agents."""
+
+# import logging
+# from typing import Annotated
+
+# from ag_ui_langgraph import add_langgraph_fastapi_endpoint
+# from copilotkit import LangGraphAGUIAgent
+# from ag_ui_adk import ADKAgent as ADKAGUIAgent
+# from ag_ui_adk import add_adk_fastapi_endpoint
+# from fastapi import APIRouter, Depends, HTTPException, Request
+
+# from idun_agent_engine.agent.langgraph.langgraph import LanggraphAgent
+# from idun_agent_engine.agent.adk.adk import AdkAgent
+# from idun_agent_engine.server.dependencies import get_agent
+
+# logging.basicConfig(
+#     format="%(asctime)s %(levelname)-8s %(message)s",
+#     level=logging.INFO,
+#     datefmt="%Y-%m-%d %H:%M:%S",
+# )
+
+# logger = logging.getLogger(__name__)
+
+
+# def setup_agui_router(app, agent: LanggraphAgent | AdkAgent) -> LangGraphAGUIAgent | ADKAGUIAgent:
+#     """Set up AGUI routes for CopilotKit integration.
+
+#     This function adds the LangGraph agent as a CopilotKit-compatible endpoint.
+
+#     Args:
+#         app: The FastAPI application instance
+#         agent: The initialized LangGraph agent instance
+#     """
+#     try:
+#         if isinstance(agent, LanggraphAgent):
+#             # Create the AGUI agent wrapper
+#             agui_agent = agent.copilotkit_agent_instance
+#         elif isinstance(agent, AdkAgent):
+#             # Create the AGUI agent wrapper
+#                 agui_agent = agent.copilotkit_agent_instance # TODO: duplicate in agent.adk.adk.py init
+#         else:
+#             raise ValueError(f"Unsupported agent type: {type(agent)}")
+#         return agui_agent
+#         logger.info(f"✅ AGUI endpoint configured at /agui for agent: {agent.name}")
+#     except Exception as e:
+#         logger.error(f"❌ Failed to setup AGUI router: {e}")
+#         raise HTTPException(status_code=500, detail=f"Failed to setup AGUI router: {e}") from e

idun_agent_engine/server/routers/base.py

@@ -1,18 +1,72 @@
 """Base routes for service health and landing info."""
 
-from fastapi import APIRouter
+import os
+from typing import Optional
+from fastapi import APIRouter, Request, HTTPException
+from pydantic import BaseModel
 
 from ..._version import __version__
+from ...core.config_builder import ConfigBuilder
+from ..lifespan import cleanup_agent, configure_app
 
 base_router = APIRouter()
 
 
+class ReloadRequest(BaseModel):
+    """Request body for reload endpoint."""
+
+    path: Optional[str] = None
+
+
 @base_router.get("/health")
 def health_check():
     """Health check endpoint for monitoring and load balancers."""
     return {"status": "healthy", "engine_version": __version__}
 
 
+@base_router.post("/reload")
+async def reload_config(request: Request, body: Optional[ReloadRequest] = None):
+    """Reload the agent configuration from the manager or a file."""
+
+    try:
+        if body and body.path:
+            print(f"🔄 Reloading configuration from file: {body.path}...")
+            new_config = ConfigBuilder.load_from_file(body.path)
+        else:
+            print("🔄 Reloading configuration from manager...")
+            agent_api_key = os.getenv("IDUN_AGENT_API_KEY")
+            manager_host = os.getenv("IDUN_MANAGER_HOST")
+
+            if not agent_api_key or not manager_host:
+                raise HTTPException(
+                    status_code=400,
+                    detail="Cannot reload from manager: IDUN_AGENT_API_KEY or IDUN_MANAGER_HOST environment variables are missing.",
+                )
+
+            # Fetch new config
+            config_builder = ConfigBuilder().with_config_from_api(
+                agent_api_key=agent_api_key, url=manager_host
+            )
+            new_config = config_builder.build()
+
+        # Cleanup old agent
+        await cleanup_agent(request.app)
+
+        # Initialize new agent
+        await configure_app(request.app, new_config)
+
+        return {
+            "status": "success",
+            "message": "Agent configuration reloaded successfully",
+        }
+
+    except Exception as e:
+        print(f"❌ Error reloading configuration: {e}")
+        raise HTTPException(
+            status_code=500, detail=f"Failed to reload configuration: {str(e)}"
+        )
+
+
 # Add a root endpoint with helpful information
 @base_router.get("/")
 def read_root():

idun_agent_engine/templates/__init__.py

@@ -0,0 +1 @@
+"""Agent templates package."""

idun_agent_engine/templates/correction.py

@@ -0,0 +1,65 @@
+"""Correction Agent Template."""
+
+import os
+from typing import TypedDict, Annotated, List, Any
+
+try:
+    from langchain.chat_models import init_chat_model
+except ImportError:
+    try:
+        from langchain_core.language_models import init_chat_model
+    except ImportError:
+        init_chat_model = None
+
+from langchain_core.messages import SystemMessage, BaseMessage
+from langgraph.graph import StateGraph, START, END
+from langgraph.graph.message import add_messages
+
+
+class State(TypedDict):
+    messages: Annotated[List[BaseMessage], add_messages]
+
+
+MODEL_NAME = os.getenv("CORRECTION_MODEL", "gemini-2.5-flash")
+LANGUAGE = os.getenv("CORRECTION_LANGUAGE", "French")
+
+llm: Any = None
+if init_chat_model and callable(init_chat_model):
+    try:
+        llm = init_chat_model(MODEL_NAME)
+    except Exception as e:
+        print(f"Warning: Failed to init model {MODEL_NAME}: {e}")
+else:
+    print("Warning: init_chat_model not found in langchain.")
+
+
+
+async def correct_text(state: State):
+    """Correct the spelling, syntax, and grammar of the text."""
+    if not llm:
+
+        return {
+            "messages": [
+                SystemMessage(content="Error: Model not initialized. Check logs.")
+            ]
+        }
+
+
+    prompt = (
+        f"You are a professional text corrector for {LANGUAGE}. "
+        f"Correct the spelling, syntax, grammar, and conjugation of the following text. "
+        f"Return ONLY the corrected text without any explanations or modifications to the meaning."
+    )
+
+    messages = [SystemMessage(content=prompt)] + state["messages"]
+
+    response = await llm.ainvoke(messages)
+    return {"messages": [response]}
+
+
+workflow = StateGraph(State)
+workflow.add_node("correct", correct_text)
+workflow.add_edge(START, "correct")
+workflow.add_edge("correct", END)
+
+graph = workflow.compile()

idun_agent_engine/templates/deep_research.py

@@ -0,0 +1,40 @@
+"""Deep Research Agent Template."""
+
+import os
+from deepagents import create_deep_agent
+from tavily import TavilyClient
+
+try:
+    from langchain.chat_models import init_chat_model
+except ImportError:
+    try:
+        from langchain_core.language_models import init_chat_model
+    except ImportError:
+        init_chat_model = None
+
+MODEL_NAME = os.getenv("DEEP_RESEARCH_MODEL", "gemini-2.5-flash")
+
+SYSTEM_PROMPT = os.getenv(
+    "DEEP_RESEARCH_PROMPT", "Conduct research and write a polished report."
+)
+
+TAVILY_API_KEY = os.getenv("TAVILY_API_KEY")
+
+tavily_client = TavilyClient(api_key=TAVILY_API_KEY)
+
+
+def internet_search(query: str, max_results: int = 5):
+    """Run a web search"""
+    return tavily_client.search(query, max_results=max_results)
+
+
+llm = None
+if init_chat_model:
+    try:
+        llm = init_chat_model(MODEL_NAME)
+    except Exception as e:
+        print(f"Warning: Failed to init model {MODEL_NAME}: {e}")
+else:
+    print("Warning: init_chat_model not found in langchain.")
+
+graph = create_deep_agent(llm, [internet_search], system_prompt=SYSTEM_PROMPT)

idun_agent_engine/templates/translation.py

@@ -0,0 +1,70 @@
+"""Translation Agent Template."""
+
+import os
+from typing import TypedDict, Annotated, List
+
+# Try importing init_chat_model, fallback if necessary
+try:
+    from langchain.chat_models import init_chat_model
+except ImportError:
+    try:
+        from langchain_core.language_models import init_chat_model
+    except ImportError:
+        init_chat_model = None
+
+from langchain_core.messages import SystemMessage, BaseMessage
+from langgraph.graph import StateGraph, START, END
+from langgraph.graph.message import add_messages
+
+
+# Define the state
+class State(TypedDict):
+    messages: Annotated[List[BaseMessage], add_messages]
+
+
+# Read configuration from environment variables
+# These are set by ConfigBuilder when initializing the agent
+MODEL_NAME = os.getenv("TRANSLATION_MODEL", "gemini-2.5-flash")
+SOURCE_LANG = os.getenv("TRANSLATION_SOURCE_LANG", "English")
+TARGET_LANG = os.getenv("TRANSLATION_TARGET_LANG", "French")
+
+# Initialize the model
+llm = None
+if init_chat_model:
+    try:
+        # init_chat_model requires langchain>=0.2.x or similar.
+        # It auto-detects provider from model name (e.g. "gpt-4" -> openai, "claude" -> anthropic)
+        # provided the integration packages are installed.
+        llm = init_chat_model(MODEL_NAME)
+    except Exception as e:
+        print(f"Warning: Failed to init model {MODEL_NAME}: {e}")
+else:
+    print("Warning: init_chat_model not found in langchain.")
+
+
+async def translate(state: State):
+    """Translate the last message."""
+    if not llm:
+        return {
+            "messages": [
+                SystemMessage(content="Error: Model not initialized. Check logs.")
+            ]
+        }
+
+    prompt = (
+        f"You are a professional translator. Translate the following text "
+        f"from {SOURCE_LANG} to {TARGET_LANG}. Output ONLY the translation."
+    )
+
+    messages = [SystemMessage(content=prompt)] + state["messages"]
+
+    response = await llm.ainvoke(messages)
+    return {"messages": [response]}
+
+
+workflow = StateGraph(State)
+workflow.add_node("translate", translate)
+workflow.add_edge(START, "translate")
+workflow.add_edge("translate", END)
+
+graph = workflow.compile()

{idun_agent_engine-0.2.7.dist-info → idun_agent_engine-0.3.1.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: idun-agent-engine
-Version: 0.2.7
+Version: 0.3.1
 Summary: Python SDK and runtime to serve AI agents with FastAPI, LangGraph, and observability.
 Project-URL: Homepage, https://github.com/geoffreyharrazi/idun-agent-platform
 Project-URL: Repository, https://github.com/geoffreyharrazi/idun-agent-platform
@@ -19,29 +19,43 @@ Classifier: Programming Language :: Python :: 3.13
 Classifier: Topic :: Software Development :: Libraries
 Classifier: Typing :: Typed
 Requires-Python: <3.14,>=3.12
+Requires-Dist: ag-ui-adk<0.4.0,>=0.3.4
 Requires-Dist: ag-ui-langgraph<0.1.0,>=0.0.20
 Requires-Dist: ag-ui-protocol<0.2.0,>=0.1.8
 Requires-Dist: aiosqlite<0.22.0,>=0.21.0
 Requires-Dist: arize-phoenix-otel<1.0.0,>=0.2.0
 Requires-Dist: arize-phoenix<12.0.0,>=11.22.0
-Requires-Dist: click>=8.2.1
+Requires-Dist: click>=8.2.0
 Requires-Dist: copilotkit<0.2.0,>=0.1.72
+Requires-Dist: deepagents<1.0.0,>=0.2.8
 Requires-Dist: fastapi<0.116.0,>=0.115.0
-Requires-Dist: google-adk<2.0.0,>=1.9.0
+Requires-Dist: google-adk<2.0.0,>=1.19.0
+Requires-Dist: google-cloud-logging<4.0.0,>=3.10.0
+Requires-Dist: guardrails-ai<0.8.0,>=0.7.0
 Requires-Dist: httpx<0.29.0,>=0.28.1
-Requires-Dist: idun-agent-schema<0.3.0,>=0.2.7
-Requires-Dist: langchain-core<0.4.0,>=0.3.72
-Requires-Dist: langchain-google-vertexai<3.0.0,>=2.0.27
-Requires-Dist: langchain<0.4,>=0.3.27
+Requires-Dist: idun-agent-schema<1.0.0,>=0.2.7
+Requires-Dist: langchain-core<2.0.0,>=1.0.0
+Requires-Dist: langchain-google-vertexai<4.0.0,>=2.0.27
+Requires-Dist: langchain-mcp-adapters<0.2.0,>=0.1.0
+Requires-Dist: langchain<2.0.0,>=1.0.0
 Requires-Dist: langfuse-haystack>=2.3.0
-Requires-Dist: langfuse==2.60.8
-Requires-Dist: langgraph-checkpoint-sqlite<3.0.0,>=2.0.11
-Requires-Dist: langgraph<0.7.0,>=0.6.3
+Requires-Dist: langfuse<4.0.0,>=2.60.8
+Requires-Dist: langgraph-checkpoint-postgres<4.0.0,>=3.0.0
+Requires-Dist: langgraph-checkpoint-sqlite<4.0.0,>=3.0.0
+Requires-Dist: langgraph<2.0.0,>=1.0.0
+Requires-Dist: mcp<2.0.0,>=1.0.0
+Requires-Dist: openinference-instrumentation-google-adk<1.0.0,>=0.1.0
+Requires-Dist: openinference-instrumentation-guardrails<1.0.0,>=0.1.0
 Requires-Dist: openinference-instrumentation-langchain<1.0.0,>=0.1.13
+Requires-Dist: openinference-instrumentation-mcp<2.0.0,>=1.0.0
+Requires-Dist: openinference-instrumentation-vertexai<1.0.0,>=0.1.0
+Requires-Dist: opentelemetry-exporter-gcp-trace<2.0.0,>=1.6.0
+Requires-Dist: opentelemetry-exporter-otlp-proto-http<2.0.0,>=1.22.0
 Requires-Dist: pydantic<3.0.0,>=2.11.7
 Requires-Dist: python-dotenv>=1.1.1
 Requires-Dist: sqlalchemy<3.0.0,>=2.0.36
 Requires-Dist: streamlit<2.0.0,>=1.47.1
+Requires-Dist: tavily-python<0.8.0,>=0.7.9
 Requires-Dist: uvicorn<0.36.0,>=0.35.0
 Description-Content-Type: text/markdown
 
@@ -214,6 +228,7 @@ agent:
 - `agent.config.graph_definition` (str): absolute or relative `path/to/file.py:variable`
 - `agent.config.checkpointer` (sqlite): `{ type: "sqlite", db_url: "sqlite:///file.db" }`
 - `agent.config.observability` (optional): provider options as shown above
+- `mcp_servers` (list, optional): collection of MCP servers that should be available to your agent runtime. Each entry matches the fields supported by `langchain-mcp-adapters` (name, transport, url/command, headers, etc.).
 
 Config can be sourced by:
 
@@ -221,6 +236,43 @@ Config can be sourced by:
 - `config_dict`: dict validated at runtime
 - `config_path`: path to YAML; defaults to `config.yaml`
 
+### MCP Servers
+
+You can mount MCP servers directly in your engine config. The engine will automatically
+create a `MultiServerMCPClient` and expose it on `app.state.mcp_registry`.
+
+```yaml
+mcp_servers:
+  - name: "math"
+    transport: "stdio"
+    command: "python"
+    args:
+      - "/path/to/math_server.py"
+  - name: "weather"
+    transport: "streamable_http"
+    url: "http://localhost:8000/mcp"
+```
+
+Inside your FastAPI dependencies or handlers:
+
+```python
+from idun_agent_engine.server.dependencies import get_mcp_registry
+
+@router.get("/mcp/{server}/tools")
+async def list_tools(server: str, registry = Depends(get_mcp_registry)):
+    return await registry.get_tools(server)
+```
+
+Or outside of FastAPI:
+
+```python
+from langchain_mcp_adapters.tools import load_mcp_tools
+
+registry = app.state.mcp_registry
+async with registry.get_session("math") as session:
+    tools = await load_mcp_tools(session)
+```
+
 ## Examples
 
 The `examples/` folder contains complete projects: