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

idun_agent_engine/_version.py

@@ -1,3 +1,3 @@
 """Version information for Idun Agent Engine."""
 
-__version__ = "0.2.7"
+__version__ = "0.3.0"

idun_agent_engine/agent/adk/__init__.py

@@ -0,0 +1,5 @@
+"""ADK Agent implementation."""
+
+from .adk import AdkAgent
+
+__all__ = ["AdkAgent"]

idun_agent_engine/agent/adk/adk.py

@@ -0,0 +1,296 @@
+"""ADK agent adapter implementing the BaseAgent protocol."""
+
+import importlib.util
+import uuid
+from collections.abc import AsyncGenerator
+from typing import Any
+
+from google.adk.apps.app import App
+from google.adk.memory import (
+    InMemoryMemoryService,
+    VertexAiMemoryBankService,
+)
+from google.adk.sessions import (
+    DatabaseSessionService,
+    InMemorySessionService,
+    VertexAiSessionService,
+)
+from idun_agent_schema.engine.adk import (
+    AdkAgentConfig,
+    AdkDatabaseSessionConfig,
+    AdkInMemoryMemoryConfig,
+    AdkInMemorySessionConfig,
+    AdkVertexAiMemoryConfig,
+    AdkVertexAiSessionConfig,
+)
+from idun_agent_schema.engine.observability_v2 import ObservabilityConfig
+
+from ag_ui_adk import ADKAgent as ADKAGUIAgent
+from idun_agent_engine.agent import base as agent_base
+from idun_agent_engine import observability
+
+
+class AdkAgent(agent_base.BaseAgent):
+    """ADK agent adapter implementing the BaseAgent protocol."""
+
+    def __init__(self):
+        """Initialize an unconfigured AdkAgent with default state."""
+        self._id = str(uuid.uuid4())
+        self._agent_type = "ADK"
+        self._agent_instance: Any = None
+        self._copilotkit_agent_instance: ADKAGUIAgent | None = None
+        self._configuration: AdkAgentConfig | None = None
+        self._name: str = "Unnamed ADK Agent"
+        self._infos: dict[str, Any] = {
+            "status": "Uninitialized",
+            "name": self._name,
+            "id": self._id,
+        }
+        self._session_service: Any = None
+        self._memory_service: Any = None
+        # Observability (provider-agnostic)
+        self._obs_callbacks: list[Any] | None = None
+
+    @property
+    def id(self) -> str:
+        """Return unique identifier for this agent instance."""
+        return self._id
+
+    @property
+    def agent_type(self) -> str:
+        """Return agent type label."""
+        return self._agent_type
+
+    @property
+    def name(self) -> str:
+        """Return configured human-readable agent name."""
+        return self._name
+
+    @property
+    def agent_instance(self) -> Any:
+        """Return the underlying ADK agent instance.
+
+        Raises:
+            RuntimeError: If the agent is not yet initialized.
+        """
+        if self._agent_instance is None:
+            raise RuntimeError("Agent not initialized. Call initialize() first.")
+        return self._agent_instance
+
+    @property
+    def copilotkit_agent_instance(self) -> ADKAGUIAgent:
+        """Return the CopilotKit agent instance.
+
+        Raises:
+            RuntimeError: If the CopilotKit agent is not yet initialized.
+        """
+        if self._copilotkit_agent_instance is None:
+            raise RuntimeError(
+                "CopilotKit agent not initialized. Call initialize() first."
+            )
+        return self._copilotkit_agent_instance
+
+    @property
+    def configuration(self) -> AdkAgentConfig:
+        """Return validated configuration.
+
+        Raises:
+            RuntimeError: If the agent has not been configured yet.
+        """
+        if not self._configuration:
+            raise RuntimeError("Agent not configured. Call initialize() first.")
+        return self._configuration
+
+    @property
+    def infos(self) -> dict[str, Any]:
+        """Return diagnostic information about the agent instance."""
+        self._infos["underlying_agent_type"] = (
+            str(type(self._agent_instance)) if self._agent_instance else "N/A"
+        )
+        return self._infos
+
+    async def initialize(
+        self,
+        config: AdkAgentConfig,
+        observability_config: list[ObservabilityConfig] | None = None,
+    ) -> None:
+        """Initialize the ADK agent asynchronously."""
+        self._configuration = AdkAgentConfig.model_validate(config)
+
+        self._name = self._configuration.app_name or "Unnamed ADK Agent"
+        self._infos["name"] = self._name
+
+        # Observability (provider-agnostic)
+        if observability_config:
+            handlers, infos = observability.create_observability_handlers(
+                observability_config # type: ignore[arg-type]
+            )
+            self._obs_callbacks = []
+            for handler in handlers:
+                # Even if callbacks aren't used by ADK directly, instantiating the handler
+                # might set up global instrumentation (e.g. Phoenix, Langfuse env vars).
+                self._obs_callbacks.extend(handler.get_callbacks())
+
+            if infos:
+                self._infos["observability"] = infos
+
+        if observability_config:
+            try:
+                # Check if langfuse is enabled in any of the observability configs
+                def _is_langfuse_provider(c: Any) -> bool:
+                    provider = getattr(c, "provider", None)
+                    if provider is None and isinstance(c, dict):
+                        provider = c.get("provider")
+
+                    if provider is not None and hasattr(provider, "value"):
+                        provider = provider.value
+
+                    return str(provider).lower() == "langfuse"
+
+                is_langfuse_enabled = any(
+                    _is_langfuse_provider(config) for config in observability_config
+                )
+
+                if is_langfuse_enabled:
+                    import os
+                    langfuse_pk = os.environ.get("LANGFUSE_PUBLIC_KEY")
+                    langfuse_host = os.environ.get("LANGFUSE_BASE_URL")
+                    print(f"LANGFUSE_PUBLIC_KEY: {langfuse_pk}")
+                    print(f"LANGFUSE_BASE_URL: {langfuse_host}")
+                    try:
+                        from openinference.instrumentation.google_adk import (
+                            GoogleADKInstrumentor,
+                        )
+
+                        GoogleADKInstrumentor().instrument()
+                        print("GoogleADKInstrumentor instrumented successfully.")
+                    except ImportError:
+                        print(
+                            "openinference-instrumentation-google-adk not installed, skipping Google ADK instrumentation."
+                        )
+                    except Exception as e:
+                        print(f"Failed to instrument Google ADK: {e}")
+            except Exception as e:
+                print(f"Error checking observability config for ADK instrumentation: {e}")
+
+        # Initialize Session Service
+        await self._initialize_session_service()
+
+        # Initialize Memory Service
+        await self._initialize_memory_service()
+
+        # Load the agent instance
+        agent = self._load_agent(self._configuration.agent)
+
+        self._agent_instance = App(root_agent=agent, name=self._name)
+
+        # Initialize CopilotKit/AG-UI Agent Wrapper
+        # TODO: Pass session and memory services when supported by AG-UI ADK adapter if needed
+        self._copilotkit_agent_instance = ADKAGUIAgent(
+            adk_agent=agent,
+            session_service=self._session_service,
+            memory_service=self._memory_service,
+            app_name=self._name,
+        )
+
+        self._infos["status"] = "Initialized"
+        self._infos["config_used"] = self._configuration.model_dump()
+
+    async def _initialize_session_service(self) -> None:
+        """Initialize the session service based on configuration."""
+        if not self._configuration:
+            raise RuntimeError("Configuration not initialized")
+
+        if not self._configuration.session_service:
+            # Default to InMemory if not specified
+            self._session_service = InMemorySessionService()
+            return
+
+        config = self._configuration.session_service
+        if isinstance(config, AdkInMemorySessionConfig):
+            self._session_service = InMemorySessionService()
+        elif isinstance(config, AdkVertexAiSessionConfig):
+            self._session_service = VertexAiSessionService(
+                project=config.project_id,
+                location=config.location,
+                agent_engine_id=config.reasoning_engine_app_name,
+            )
+        elif isinstance(config, AdkDatabaseSessionConfig):
+            self._session_service = DatabaseSessionService(db_url=config.db_url)
+        else:
+            raise ValueError(f"Unsupported session service type: {config.type}")  # type: ignore
+
+    async def _initialize_memory_service(self) -> None:
+        """Initialize the memory service based on configuration."""
+        if not self._configuration:
+            raise RuntimeError("Configuration not initialized")
+
+        if not self._configuration.memory_service:
+            # Default to InMemory if not specified
+            self._memory_service = InMemoryMemoryService()
+            return
+
+        config = self._configuration.memory_service
+        if isinstance(config, AdkInMemoryMemoryConfig):
+            self._memory_service = InMemoryMemoryService()
+        elif isinstance(config, AdkVertexAiMemoryConfig):
+            self._memory_service = VertexAiMemoryBankService(
+                project=config.project_id,
+                location=config.location,
+                agent_engine_id=config.memory_bank_id,
+            )
+        else:
+            raise ValueError(f"Unsupported memory service type: {config.type}")  # type: ignore
+
+    def _load_agent(self, agent_definition: str) -> Any:
+        """Loads an agent instance from a specified path."""
+        try:
+            module_path, agent_variable_name = agent_definition.rsplit(":", 1)
+        except ValueError:
+            raise ValueError(
+                "agent_definition must be in the format 'path/to/file.py:variable_name'"
+            ) from None
+
+        try:
+            from pathlib import Path
+
+            resolved_path = Path(module_path).resolve()
+            spec = importlib.util.spec_from_file_location(
+                agent_variable_name, str(resolved_path)
+            )
+            if spec is None or spec.loader is None:
+                raise ImportError(f"Could not load spec for module at {module_path}")
+
+            module = importlib.util.module_from_spec(spec)
+            spec.loader.exec_module(module)
+
+            agent_instance = getattr(module, agent_variable_name)
+            return agent_instance
+        except (FileNotFoundError, ImportError, AttributeError) as e:
+            raise ValueError(
+                f"Failed to load agent from {agent_definition}: {e}"
+            ) from e
+
+    async def invoke(self, message: Any) -> Any:
+        """Process a single input to chat with the agent."""
+        if self._agent_instance is None:
+            raise RuntimeError(
+                "Agent not initialized. Call initialize() before processing messages."
+            )
+
+        # TODO: Implement ADK invoke logic using session and memory services
+        raise NotImplementedError("ADK invoke not implemented yet")
+
+    async def stream(self, message: Any) -> AsyncGenerator[Any]:
+        """Process a single input message and return an asynchronous stream."""
+        if self._agent_instance is None:
+            raise RuntimeError(
+                "Agent not initialized. Call initialize() before processing messages."
+            )
+
+        # TODO: Implement ADK stream logic using session and memory services
+        raise NotImplementedError("ADK stream not implemented yet")
+
+        # Required to make this a generator
+        if False:
+            yield

idun_agent_engine/agent/base.py

@@ -8,6 +8,7 @@ from collections.abc import AsyncGenerator
 from typing import Any
 
 from idun_agent_schema.engine.agent import BaseAgentConfig
+from idun_agent_schema.engine.observability_v2 import ObservabilityConfig
 
 
 class BaseAgent[ConfigType: BaseAgentConfig](ABC):
@@ -63,13 +64,18 @@ class BaseAgent[ConfigType: BaseAgentConfig](ABC):
         pass
 
     @abstractmethod
-    async def initialize(self, config: dict[str, Any]) -> None:
+    async def initialize(
+        self,
+        config: dict[str, Any],
+        observability: list[ObservabilityConfig] | None = None,
+    ) -> None:
         """Initialize the agent with a given configuration.
 
         This method should set up the underlying agent framework instance.
 
         Args:
             config: A dictionary containing the agent's configuration.
+            observability: Optional list of observability configurations.
         """
         pass
 

idun_agent_engine/agent/haystack/haystack.py

@@ -126,7 +126,11 @@ class HaystackAgent(BaseAgent):
                 self._langfuse_tracing = True
         logger.info("Agent tracing not supported yet")
 
-    async def initialize(self, config: HaystackAgentConfig | dict[str, Any]) -> None:
+    async def initialize(
+        self,
+        config: HaystackAgentConfig | dict[str, Any],
+        observability_config: list[ObservabilityConfig] | None = None,
+    ) -> None:
         try:
             logger.debug(f"Initializing haystack agent config: {config}...")
 

idun_agent_engine/agent/langgraph/langgraph.py

@@ -1,6 +1,7 @@
 """LangGraph agent adapter implementing the BaseAgent protocol."""
 
 import importlib.util
+import importlib
 import uuid
 from collections.abc import AsyncGenerator
 from typing import Any
@@ -9,11 +10,17 @@ import aiosqlite
 from ag_ui.core import events as ag_events
 from ag_ui.core import types as ag_types
 from idun_agent_schema.engine.langgraph import (
+    InMemoryCheckpointConfig,
     LangGraphAgentConfig,
+    PostgresCheckpointConfig,
     SqliteCheckpointConfig,
 )
+from idun_agent_schema.engine.observability_v2 import ObservabilityConfig
+from langgraph.checkpoint.memory import InMemorySaver
+from langgraph.checkpoint.postgres.aio import AsyncPostgresSaver
 from langgraph.checkpoint.sqlite.aio import AsyncSqliteSaver
 from langgraph.graph import StateGraph
+from langgraph.graph.state import CompiledStateGraph
 
 from idun_agent_engine import observability
 from idun_agent_engine.agent import base as agent_base
@@ -111,7 +118,11 @@ class LanggraphAgent(agent_base.BaseAgent):
         )
         return self._infos
 
-    async def initialize(self, config: LangGraphAgentConfig) -> None:
+    async def initialize(
+        self,
+        config: LangGraphAgentConfig,
+        observability_config: list[ObservabilityConfig] | None = None,
+    ) -> None:
         """Initialize the LangGraph agent asynchronously."""
         self._configuration = LangGraphAgentConfig.model_validate(config)
 
@@ -120,55 +131,83 @@ class LanggraphAgent(agent_base.BaseAgent):
 
         await self._setup_persistence()
 
-        # Observability (provider-agnostic). Prefer generic block; fallback to legacy langfuse block.
-        obs_cfg = None
-        try:
-            if getattr(self._configuration, "observability", None):
-                obs_cfg = self._configuration.observability.resolved()  # type: ignore[attr-defined]
-            elif getattr(self._configuration, "langfuse", None):
-                lf = self._configuration.langfuse.resolved()  # type: ignore[attr-defined]
-                obs_cfg = type(
-                    "_Temp",
-                    (),
-                    {
-                        "provider": "langfuse",
-                        "enabled": lf.enabled,
-                        "options": {
-                            "host": lf.host,
-                            "public_key": lf.public_key,
-                            "secret_key": lf.secret_key,
-                            "run_name": lf.run_name,
-                        },
-                    },
-                )()
-        except Exception:
-            obs_cfg = None
-
-        if obs_cfg and getattr(obs_cfg, "enabled", False):
-            provider = getattr(obs_cfg, "provider", None)
-            options = dict(getattr(obs_cfg, "options", {}) or {})
-            # Fallback: if using Langfuse and run_name is not provided, use agent name
-            if provider == "langfuse" and not options.get("run_name"):
-                options["run_name"] = self._name
-
-            handler, info = observability.create_observability_handler(
-                {
-                    "provider": provider,
-                    "enabled": True,
-                    "options": options,
-                }
+        # Observability (provider-agnostic)
+        if observability_config:
+            handlers, infos = observability.create_observability_handlers(
+                observability_config # type: ignore[arg-type]
             )
-            if handler:
-                self._obs_callbacks = handler.get_callbacks()
-                self._obs_run_name = handler.get_run_name()
-            if info:
-                self._infos["observability"] = dict(info)
+            self._obs_callbacks = []
+            for handler in handlers:
+                self._obs_callbacks.extend(handler.get_callbacks())
+                # Use the first run name found if not set
+                if not self._obs_run_name:
+                    self._obs_run_name = handler.get_run_name()
+
+            if infos:
+                self._infos["observability"] = infos
+
+        # Fallback to legacy generic block or langfuse block if no new observability config provided
+        elif getattr(self._configuration, "observability", None) or getattr(
+            self._configuration, "langfuse", None
+        ):
+            obs_cfg = None
+            try:
+                if getattr(self._configuration, "observability", None):
+                    obs_cfg = self._configuration.observability.resolved()  # type: ignore[attr-defined]
+                elif getattr(self._configuration, "langfuse", None):
+                    lf = self._configuration.langfuse.resolved()  # type: ignore[attr-defined]
+                    obs_cfg = type(
+                        "_Temp",
+                        (),
+                        {
+                            "provider": "langfuse",
+                            "enabled": lf.enabled,
+                            "options": {
+                                "host": lf.host,
+                                "public_key": lf.public_key,
+                                "secret_key": lf.secret_key,
+                                "run_name": lf.run_name,
+                            },
+                        },
+                    )()
+            except Exception:
+                obs_cfg = None
+
+            if obs_cfg and getattr(obs_cfg, "enabled", False):
+                provider = getattr(obs_cfg, "provider", None)
+                options = dict(getattr(obs_cfg, "options", {}) or {})
+                # Fallback: if using Langfuse and run_name is not provided, use agent name
+                if provider == "langfuse" and not options.get("run_name"):
+                    options["run_name"] = self._name
+
+                handler, info = observability.create_observability_handler(
+                    {
+                        "provider": provider,
+                        "enabled": True,
+                        "options": options,
+                    }
+                )
+                if handler:
+                    self._obs_callbacks = handler.get_callbacks()
+                    self._obs_run_name = handler.get_run_name()
+                if info:
+                    self._infos["observability"] = dict(info)
 
         graph_builder = self._load_graph_builder(self._configuration.graph_definition)
         self._infos["graph_definition"] = self._configuration.graph_definition
 
-        self._agent_instance = graph_builder.compile(
-            checkpointer=self._checkpointer, store=self._store
+        if isinstance(graph_builder, StateGraph):
+            self._agent_instance = graph_builder.compile(
+                checkpointer=self._checkpointer, store=self._store
+            )
+        elif isinstance(graph_builder, CompiledStateGraph):
+            self._agent_instance = graph_builder
+
+        self._copilotkit_agent_instance = LangGraphAGUIAgent(
+            name=self._name,
+            description="Agent description", # TODO: add agent description
+            graph=self._agent_instance,
+            config={"callbacks": self._obs_callbacks} if self._obs_callbacks else None,
         )
 
         self._copilotkit_agent_instance = LangGraphAGUIAgent(
@@ -178,10 +217,18 @@ class LanggraphAgent(agent_base.BaseAgent):
         )
 
         if self._agent_instance:
-            self._input_schema = self._agent_instance.input_schema
-            self._output_schema = self._agent_instance.output_schema
-            self._infos["input_schema"] = str(self._input_schema)
-            self._infos["output_schema"] = str(self._output_schema)
+            try:
+                self._input_schema = self._agent_instance.input_schema
+                self._output_schema = self._agent_instance.output_schema
+                self._infos["input_schema"] = str(self._input_schema)
+                self._infos["output_schema"] = str(self._output_schema)
+            except Exception:
+                print("Could not parse schema")
+                self._input_schema = self._configuration.input_schema_definition
+                self._output_schema = self._configuration.output_schema_definition
+                self._infos["input_schema"] = "Cannot extract schema"
+                self._infos["output_schema"] = "Cannot extract schema"
+
         else:
             self._input_schema = self._configuration.input_schema_definition
             self._output_schema = self._configuration.output_schema_definition
@@ -210,8 +257,23 @@ class LanggraphAgent(agent_base.BaseAgent):
                 self._infos["checkpointer"] = (
                     self._configuration.checkpointer.model_dump()
                 )
+            elif isinstance(self._configuration.checkpointer, InMemoryCheckpointConfig):
+                self._checkpointer = InMemorySaver()
+                self._infos["checkpointer"] = (
+                    self._configuration.checkpointer.model_dump()
+                )
+            elif isinstance(self._configuration.checkpointer, PostgresCheckpointConfig):
+                self._checkpointer = AsyncPostgresSaver.from_conn_string(
+                    self._configuration.checkpointer.db_url
+                )
+                await self._checkpointer.setup()
+                self._infos["checkpointer"] = (
+                    self._configuration.checkpointer.model_dump()
+                )
             else:
-                raise NotImplementedError("Only SQLite checkpointer is supported.")
+                raise NotImplementedError(
+                    f"Checkpointer type {type(self._configuration.checkpointer)} is not supported."
+                )
 
         if self._configuration.store:
             raise NotImplementedError("Store functionality is not yet implemented.")
@@ -220,14 +282,24 @@ class LanggraphAgent(agent_base.BaseAgent):
         """Loads a StateGraph instance from a specified path."""
         try:
             module_path, graph_variable_name = graph_definition.rsplit(":", 1)
+            if not module_path.endswith(".py"):
+                module_path += ".py"
         except ValueError:
             raise ValueError(
                 "graph_definition must be in the format 'path/to/file.py:variable_name'"
             ) from None
 
+        # Try loading as a file path first
         try:
+            import os
+            print("Current directory: ", os.getcwd()) # TODO remove
             from pathlib import Path
+
             resolved_path = Path(module_path).resolve()
+            # If the file doesn't exist, it might be a python module path
+            if not resolved_path.exists():
+                raise FileNotFoundError
+
             spec = importlib.util.spec_from_file_location(
                 graph_variable_name, str(resolved_path)
             )
@@ -238,17 +310,36 @@ class LanggraphAgent(agent_base.BaseAgent):
             spec.loader.exec_module(module)
 
             graph_builder = getattr(module, graph_variable_name)
-        except (FileNotFoundError, ImportError, AttributeError) as e:
-            raise ValueError(
+            return self._validate_graph_builder(graph_builder, module_path, graph_variable_name)
+
+        except (FileNotFoundError, ImportError):
+            # Fallback: try loading as a python module
+            try:
+                module = importlib.import_module(module_path)
+                graph_builder = getattr(module, graph_variable_name)
+                return self._validate_graph_builder(graph_builder, module_path, graph_variable_name)
+            except ImportError as e:
+                 raise ValueError(
+                    f"Failed to load agent from {graph_definition}. Checked file path and python module: {e}"
+                ) from e
+            except AttributeError as e:
+                raise ValueError(
+                    f"Variable '{graph_variable_name}' not found in module {module_path}: {e}"
+                ) from e
+        except Exception as e:
+             raise ValueError(
                 f"Failed to load agent from {graph_definition}: {e}"
             ) from e
 
-        if not isinstance(graph_builder, StateGraph):
+    def _validate_graph_builder(self, graph_builder: Any, module_path: str, graph_variable_name: str) -> StateGraph:
+         # TODO to remove, dirty fix for template deepagent langgraph
+        if not isinstance(graph_builder, StateGraph) and not isinstance(
+            graph_builder, CompiledStateGraph
+        ):
             raise TypeError(
                 f"The variable '{graph_variable_name}' from {module_path} is not a StateGraph instance."
             )
-
-        return graph_builder
+        return graph_builder # type: ignore[return-value]
 
     async def invoke(self, message: Any) -> Any:
         """Process a single input to chat with the agent.

idun_agent_engine/core/app_factory.py

@@ -8,6 +8,7 @@ setting up routes, dependencies, and lifecycle management behind the scenes.
 from typing import Any
 
 from fastapi import FastAPI
+from fastapi.middleware.cors import CORSMiddleware
 
 from ..server.lifespan import lifespan
 from ..server.routers.agent import agent_router
@@ -54,6 +55,14 @@ def create_app(
         redoc_url="/redoc",
     )
 
+    app.add_middleware(
+        CORSMiddleware,
+        allow_origins=["*"],
+        allow_credentials=True,
+        allow_methods=["*"],
+        allow_headers=["*"],
+    )
+
     # Store configuration in app state for lifespan to use
     app.state.engine_config = validated_config