agentomatic 0.1.0__py3-none-any.whl

agentomatic/cli/templates.py

@@ -0,0 +1,188 @@
+"""Agent scaffolding templates.
+
+Each template is a dict mapping relative file paths to their content.
+Templates: basic, full, rag, chatbot, custom.
+"""
+
+from __future__ import annotations
+
+
+def _init_py(name: str, description: str, keywords: str, framework: str = "langgraph") -> str:
+    return f'''"""Agent: {name}."""\nfrom __future__ import annotations\n\nfrom typing import Any\n\nfrom agentomatic import AgentManifest\n\nmanifest = AgentManifest(\n    name="{name}",\n    slug="agent-{name}",\n    description="{description}",\n    intent_keywords=[{keywords}],\n    framework="{framework}",\n)\n\n\nasync def node_fn(state: dict[str, Any]) -> dict[str, Any]:\n    from .graph import get_graph\n    return await get_graph().ainvoke(state)\n'''
+
+
+def _graph_py(name: str) -> str:
+    return f'''"""LangGraph graph for {name}."""\nfrom __future__ import annotations\n\nfrom functools import lru_cache\n\nfrom langgraph.graph import END, StateGraph\n\nfrom agentomatic import BaseAgentState\n\nfrom . import nodes\n\n\ndef build_graph() -> StateGraph:\n    g = StateGraph(BaseAgentState)\n    g.add_node("process", nodes.process)\n    g.set_entry_point("process")\n    g.add_edge("process", END)\n    return g\n\n\n@lru_cache(maxsize=1)\ndef get_graph():\n    return build_graph().compile()\n'''
+
+
+def _nodes_py(name: str) -> str:
+    return f'''"""Node functions for {name}."""\nfrom __future__ import annotations\n\nfrom typing import Any\n\n\nasync def process(state: dict[str, Any]) -> dict[str, Any]:\n    query = state.get("current_query", "")\n    return {{\n        "response": f"Hello from {name}! You asked: {{query}}",\n        "agent_type": "agent-{name}",\n        "suggestions": ["Tell me more", "Help me with something else"],\n    }}\n'''
+
+
+def _config_py(name: str) -> str:
+    title = name.replace("_", " ").title()
+    return f'''"""Configuration for {title} agent."""\nfrom __future__ import annotations\n\nfrom pydantic import BaseModel, Field\n\n\nclass {title.replace(" ", "")}Config(BaseModel):\n    """Agent-specific configuration."""\n\n    prompt_version: str = Field("v1", description="Active prompt version")\n    temperature: float = Field(0.1, ge=0.0, le=2.0)\n    max_tokens: int = Field(2048, ge=1)\n    enable_memory: bool = Field(True, description="Enable conversation memory")\n'''
+
+
+def _schemas_py(name: str) -> str:
+    title = name.replace("_", " ").title().replace(" ", "")
+    return f'''"""Custom schemas for {name}."""\nfrom __future__ import annotations\n\nfrom pydantic import BaseModel, Field\n\n\nclass {title}Request(BaseModel):\n    """Custom request model."""\n    query: str = Field(..., description="User query")\n    context: dict = Field(default_factory=dict)\n\n\nclass {title}Response(BaseModel):\n    """Custom response model."""\n    answer: str\n    confidence: float = Field(0.0, ge=0.0, le=1.0)\n    sources: list[str] = Field(default_factory=list)\n'''
+
+
+def _tools_py(name: str) -> str:
+    return f'''"""LangChain-compatible tools for {name}."""\nfrom __future__ import annotations\n\n\ndef search(query: str) -> str:\n    """Search for information.\n\n    Args:\n        query: Search query string.\n\n    Returns:\n        Search results.\n    """\n    return f"Results for: {{query}}"\n'''
+
+
+def _api_py(name: str) -> str:
+    return f'''"""Custom API router for {name}.\n\nIf this file exports a `router`, it REPLACES the auto-generated endpoints.\nRemove this file to use auto-generated endpoints instead.\n"""\nfrom __future__ import annotations\n\nfrom fastapi import APIRouter\n\nrouter = APIRouter()\n\n\n@router.get("/status")\nasync def status() -> dict:\n    """Custom status endpoint."""\n    return {{"agent": "{name}", "custom_router": True}}\n'''
+
+
+def _prompts_json() -> str:
+    return """{
+    "v1": {
+        "system": "You are a helpful AI assistant. Be concise and accurate.",
+        "user_template": "{query}"
+    },
+    "v2": {
+        "system": "You are an advanced AI assistant. Provide detailed, well-structured responses with examples when helpful.",
+        "user_template": "Please help with the following: {query}"
+    }
+}
+"""
+
+
+def _langgraph_json() -> str:
+    return """{
+    "dependencies": ["."],
+    "graphs": {
+        "agent": "./graph.py:get_graph"
+    },
+    "env": ".env"
+}
+"""
+
+
+def _env_example(name: str) -> str:
+    upper = name.upper()
+    return f"""# {name} agent configuration\n# Copy to .env and fill in values\n\n# LLM Settings\n{upper}_LLM_PROVIDER=ollama\n{upper}_LLM_MODEL=mistral:7b\n{upper}_TEMPERATURE=0.1\n{upper}_MAX_TOKENS=2048\n\n# Feature Flags\n{upper}_ENABLE_MEMORY=true\n{upper}_ENABLE_STREAMING=true\n"""
+
+
+def _readme_md(name: str, template: str) -> str:
+    title = name.replace("_", " ").title()
+    return f"""# {title} Agent\n\nGenerated with `agentomatic init {name} --template {template}`.\n\n## Quick Start\n\n```bash\n# Start the platform\nagentomatic run\n\n# Test the agent\ncurl -X POST http://localhost:8000/api/v1/{name}/invoke \\\n  -H "Content-Type: application/json" \\\n  -d '{{"query": "Hello!"}}'\n```\n\n## Files\n\n| File | Purpose |\n|------|---------|\n| `__init__.py` | Agent manifest and entry point |\n| `graph.py` | LangGraph state graph |\n| `nodes.py` | Node processing functions |\n| `config.py` | Agent-specific configuration |\n| `prompts.json` | Versioned prompt templates |\n| `langgraph.json` | LangGraph Studio config |\n"""
+
+
+# --- RAG-specific templates ---
+
+
+def _rag_nodes_py(name: str) -> str:
+    return f'''"""RAG node functions for {name}."""\nfrom __future__ import annotations\n\nfrom typing import Any\n\n\nasync def retrieve(state: dict[str, Any]) -> dict[str, Any]:\n    """Retrieve relevant documents."""\n    query = state.get("current_query", "")\n    # TODO: Replace with real vector search\n    docs = [\n        {{"content": f"Document about {{query}}", "source": "knowledge_base"}},\n    ]\n    return {{"citations": docs, "steps_taken": ["retrieved_docs"]}}\n\n\nasync def generate(state: dict[str, Any]) -> dict[str, Any]:\n    """Generate response using retrieved context."""\n    query = state.get("current_query", "")\n    citations = state.get("citations", [])\n    context = "\\n".join(d.get("content", "") for d in citations)\n    return {{\n        "response": f"Based on the knowledge base: Answer to '{{query}}' using context: {{context}}",\n        "agent_type": "agent-{name}",\n        "steps_taken": ["generated_response"],\n    }}\n'''
+
+
+def _rag_graph_py(name: str) -> str:
+    return f'''"""RAG graph for {name}: retrieve -> generate."""\nfrom __future__ import annotations\n\nfrom functools import lru_cache\n\nfrom langgraph.graph import END, StateGraph\n\nfrom agentomatic import BaseAgentState\n\nfrom . import nodes\n\n\ndef build_graph() -> StateGraph:\n    g = StateGraph(BaseAgentState)\n    g.add_node("retrieve", nodes.retrieve)\n    g.add_node("generate", nodes.generate)\n    g.set_entry_point("retrieve")\n    g.add_edge("retrieve", "generate")\n    g.add_edge("generate", END)\n    return g\n\n\n@lru_cache(maxsize=1)\ndef get_graph():\n    return build_graph().compile()\n'''
+
+
+# --- Chatbot-specific templates ---
+
+
+def _chatbot_nodes_py(name: str) -> str:
+    return f'''"""Chatbot node functions for {name} with conversation memory."""\nfrom __future__ import annotations\n\nfrom typing import Any\n\n\nasync def respond(state: dict[str, Any]) -> dict[str, Any]:\n    """Generate a conversational response."""\n    query = state.get("current_query", "")\n    messages = state.get("messages", [])\n    history_len = len(messages)\n\n    # TODO: Replace with real LLM call\n    return {{\n        "response": f"[Turn {{history_len + 1}}] You said: {{query}}",\n        "agent_type": "agent-{name}",\n        "suggestions": ["Tell me more", "Change topic", "Goodbye"],\n    }}\n'''
+
+
+def _chatbot_graph_py(name: str) -> str:
+    return f'''"""Chatbot graph for {name} with memory."""\nfrom __future__ import annotations\n\nfrom functools import lru_cache\n\nfrom langgraph.graph import END, StateGraph\n\nfrom agentomatic import BaseAgentState\n\nfrom . import nodes\n\n\ndef build_graph() -> StateGraph:\n    g = StateGraph(BaseAgentState)\n    g.add_node("respond", nodes.respond)\n    g.set_entry_point("respond")\n    g.add_edge("respond", END)\n    return g\n\n\n@lru_cache(maxsize=1)\ndef get_graph():\n    return build_graph().compile()\n'''
+
+
+# --- Custom (no LangGraph) template ---
+
+
+def _custom_init_py(name: str, description: str, keywords: str) -> str:
+    return f'''"""Agent: {name} (framework-agnostic)."""\nfrom __future__ import annotations\n\nfrom typing import Any\n\nfrom agentomatic import AgentManifest\n\nmanifest = AgentManifest(\n    name="{name}",\n    slug="agent-{name}",\n    description="{description}",\n    intent_keywords=[{keywords}],\n    framework="custom",\n)\n\n\nasync def node_fn(state: dict[str, Any]) -> dict[str, Any]:\n    """Process the request directly — no graph framework needed."""\n    query = state.get("current_query", "")\n    return {{\n        "response": f"Hello from {name}! You asked: {{query}}",\n        "agent_type": "agent-{name}",\n    }}\n'''
+
+
+# =====================================================================
+# Template Registry
+# =====================================================================
+
+TEMPLATES: dict[str, str] = {
+    "basic": "Minimal agent — 3 files, quick start",
+    "full": "All overwrite files — config, schemas, api, tools, prompts",
+    "rag": "RAG agent — retrieve → generate pipeline",
+    "chatbot": "Conversational agent with memory",
+    "custom": "Framework-agnostic — no LangGraph dependency",
+}
+
+
+def get_template_files(template: str, name: str) -> dict[str, str]:
+    """Get all files for a given template.
+
+    Args:
+        template: Template name (basic, full, rag, chatbot, custom).
+        name: Agent name.
+
+    Returns:
+        Dict mapping relative file paths to content strings.
+    """
+    title = name.replace("_", " ").title()
+    description = f"{title} agent"
+    keywords = f'"{name}"'
+
+    common = {
+        "prompts.json": _prompts_json(),
+        "langgraph.json": _langgraph_json(),
+        ".env.example": _env_example(name),
+        "README.md": _readme_md(name, template),
+    }
+
+    if template == "basic":
+        return {
+            "__init__.py": _init_py(name, description, keywords),
+            "graph.py": _graph_py(name),
+            "nodes.py": _nodes_py(name),
+            **common,
+        }
+
+    elif template == "full":
+        return {
+            "__init__.py": _init_py(name, description, keywords),
+            "graph.py": _graph_py(name),
+            "nodes.py": _nodes_py(name),
+            "config.py": _config_py(name),
+            "schemas.py": _schemas_py(name),
+            "tools.py": _tools_py(name),
+            "api.py": _api_py(name),
+            **common,
+        }
+
+    elif template == "rag":
+        return {
+            "__init__.py": _init_py(
+                name, f"{title} RAG agent", f'"{name}", "search", "knowledge"'
+            ),
+            "graph.py": _rag_graph_py(name),
+            "nodes.py": _rag_nodes_py(name),
+            "config.py": _config_py(name),
+            "tools.py": _tools_py(name),
+            **common,
+        }
+
+    elif template == "chatbot":
+        return {
+            "__init__.py": _init_py(name, f"{title} chatbot", f'"{name}", "chat", "conversation"'),
+            "graph.py": _chatbot_graph_py(name),
+            "nodes.py": _chatbot_nodes_py(name),
+            "config.py": _config_py(name),
+            **common,
+        }
+
+    elif template == "custom":
+        return {
+            "__init__.py": _custom_init_py(name, description, keywords),
+            ".env.example": _env_example(name),
+            "README.md": _readme_md(name, template),
+            "prompts.json": _prompts_json(),
+        }
+
+    else:
+        raise ValueError(f"Unknown template: {template}. Choose from: {list(TEMPLATES.keys())}")

agentomatic/config/__init__.py

@@ -0,0 +1,3 @@
+"""Agentomatic configuration system."""
+
+from __future__ import annotations

agentomatic/config/defaults.py

@@ -0,0 +1,10 @@
+"""Default configuration values."""
+
+from __future__ import annotations
+
+DEFAULT_API_PREFIX = "/api/v1"
+DEFAULT_LOG_LEVEL = "INFO"
+DEFAULT_LLM_PROVIDER = "ollama"
+DEFAULT_LLM_MODEL = "mistral:7b"
+DEFAULT_TEMPERATURE = 0.1
+DEFAULT_MAX_TOKENS = 4096

agentomatic/config/settings.py

@@ -0,0 +1,117 @@
+"""Platform settings with feature flags and nested configuration."""
+
+from __future__ import annotations
+
+from pydantic import BaseModel, Field
+from pydantic_settings import BaseSettings, SettingsConfigDict
+
+
+class LLMSettings(BaseModel):
+    """LLM provider configuration."""
+
+    provider: str = Field("ollama", description="LLM provider: ollama|azure|openai|vertex|dummy")
+    model: str = Field("mistral:7b", description="Model name")
+    temperature: float = Field(0.1, ge=0.0, le=2.0)
+    max_tokens: int = Field(4096, ge=1)
+    ollama_base_url: str = Field("http://localhost:11434")
+    azure_api_key: str = Field("", description="Azure OpenAI API key")
+    azure_api_base: str = Field("")
+    azure_api_version: str = Field("2024-02-15-preview")
+    azure_deployment_name: str = Field("")
+    openai_api_key: str = Field("")
+    vertex_project: str = Field("")
+    vertex_location: str = Field("us-central1")
+
+
+class EmbeddingSettings(BaseModel):
+    """Embedding provider configuration."""
+
+    provider: str = Field("dummy", description="Embedding provider: ollama|dummy")
+    model: str = Field("nomic-embed-text")
+    dimension: int = Field(768)
+
+
+class DatabaseSettings(BaseModel):
+    """Database configuration."""
+
+    url: str = Field("sqlite+aiosqlite:///data/platform.db")
+    pool_size: int = Field(10, ge=1)
+    max_overflow: int = Field(20, ge=0)
+    pool_timeout: int = Field(30, ge=1)
+    echo: bool = Field(False)
+
+
+class FeatureSettings(BaseModel):
+    """Feature flags for the platform."""
+
+    enable_streaming: bool = Field(True, description="Enable SSE streaming endpoints")
+    enable_a2a: bool = Field(True, description="Enable A2A protocol")
+    enable_metrics: bool = Field(True, description="Enable Prometheus metrics")
+    enable_rate_limit: bool = Field(False, description="Enable rate limiting")
+    enable_auth: bool = Field(False, description="Enable API key authentication")
+    enable_db: bool = Field(False, description="Enable database storage")
+    enable_feedback: bool = Field(True, description="Enable feedback collection")
+    max_concurrent_agents: int = Field(10, ge=1)
+    request_timeout: float = Field(30.0, gt=0)
+    llm_retry_count: int = Field(3, ge=0)
+    llm_retry_delay: float = Field(1.0, ge=0)
+    circuit_breaker_threshold: int = Field(5, ge=1)
+    circuit_breaker_timeout: float = Field(60.0, gt=0)
+
+
+class AuthSettings(BaseModel):
+    """Authentication configuration."""
+
+    api_key: str = Field("", description="API key for authentication")
+
+
+class RateLimitSettings(BaseModel):
+    """Rate limiting configuration."""
+
+    requests: int = Field(100, ge=1)
+    window_seconds: int = Field(60, ge=1)
+
+
+class PlatformSettings(BaseSettings):
+    """Root platform configuration.
+
+    Priority: env vars > .env > YAML > defaults.
+    Nested delimiter: __ (double underscore).
+    """
+
+    app_name: str = Field("Agentomatic Platform")
+    app_env: str = Field("development")
+    log_level: str = Field("INFO")
+    api_version: str = Field("v1")
+
+    llm: LLMSettings = Field(default_factory=LLMSettings)  # type: ignore[arg-type]
+    embedding: EmbeddingSettings = Field(default_factory=EmbeddingSettings)  # type: ignore[arg-type]
+    db: DatabaseSettings = Field(default_factory=DatabaseSettings)  # type: ignore[arg-type]
+    features: FeatureSettings = Field(default_factory=FeatureSettings)  # type: ignore[arg-type]
+    auth: AuthSettings = Field(default_factory=AuthSettings)  # type: ignore[arg-type]
+    rate_limit: RateLimitSettings = Field(default_factory=RateLimitSettings)  # type: ignore[arg-type]
+
+    model_config = SettingsConfigDict(
+        env_prefix="",
+        env_nested_delimiter="__",
+        env_file=".env",
+        env_file_encoding="utf-8",
+        extra="ignore",
+    )
+
+
+_settings: PlatformSettings | None = None
+
+
+def get_settings() -> PlatformSettings:
+    """Get or create the singleton settings instance."""
+    global _settings
+    if _settings is None:
+        _settings = PlatformSettings()  # type: ignore[call-arg]
+    return _settings
+
+
+def reset_settings() -> None:
+    """Reset settings singleton (for testing)."""
+    global _settings
+    _settings = None

agentomatic/core/__init__.py

@@ -0,0 +1,31 @@
+"""Agentomatic core — platform, registry, manifest, state."""
+
+from __future__ import annotations
+
+from .lifespan import configure_logging, create_lifespan
+from .manifest import AgentManifest, RegisteredAgent
+from .platform import AgentPlatform
+from .registry import AgentRegistry
+from .router_factory import (
+    A2ATaskRequest,
+    AgentChatRequest,
+    AgentInvokeRequest,
+    AgentInvokeResponse,
+    create_default_router,
+)
+from .state import BaseAgentState
+
+__all__ = [
+    "A2ATaskRequest",
+    "AgentChatRequest",
+    "AgentInvokeRequest",
+    "AgentInvokeResponse",
+    "AgentManifest",
+    "AgentPlatform",
+    "AgentRegistry",
+    "BaseAgentState",
+    "RegisteredAgent",
+    "configure_logging",
+    "create_default_router",
+    "create_lifespan",
+]

agentomatic/core/lifespan.py

@@ -0,0 +1,102 @@
+"""Application lifespan management."""
+
+from __future__ import annotations
+
+import sys
+from collections.abc import AsyncIterator, Callable
+from contextlib import asynccontextmanager
+from pathlib import Path
+from typing import TYPE_CHECKING, Any
+
+from loguru import logger
+
+if TYPE_CHECKING:
+    from fastapi import FastAPI
+
+
+def configure_logging(level: str = "INFO") -> None:
+    """Configure loguru with a standard format.
+
+    Removes all existing handlers and installs a single ``stdout``
+    sink with coloured, structured output.
+
+    Args:
+        level: Minimum log level (e.g. ``"DEBUG"``, ``"INFO"``).
+    """
+    logger.remove()
+    logger.add(
+        sys.stdout,
+        level=level.upper(),
+        format=(
+            "<green>{time:YYYY-MM-DD HH:mm:ss.SSS}</green> | "
+            "<level>{level: <8}</level> | "
+            "<cyan>{name}</cyan>:<cyan>{function}</cyan>:<cyan>{line}</cyan> — "
+            "<level>{message}</level>"
+        ),
+    )
+
+
+@asynccontextmanager
+async def create_lifespan(
+    registry: Any,
+    agents_dir: str | Path,
+    package_prefix: str,
+    settings: Any,
+    on_startup: list[Callable[..., Any]] | None = None,
+    on_shutdown: list[Callable[..., Any]] | None = None,
+) -> AsyncIterator[Callable[[FastAPI], Any]]:
+    """Create a FastAPI lifespan context manager.
+
+    Startup sequence:
+      1. Configure logging
+      2. Discover agents
+      3. Run custom startup hooks
+
+    Shutdown sequence:
+      1. Run custom shutdown hooks
+
+    Args:
+        registry: The :class:`AgentRegistry` instance.
+        agents_dir: Path to the agents directory.
+        package_prefix: Python package prefix for agent imports.
+        settings: Application settings object.
+        on_startup: Optional list of callables to run at startup.
+        on_shutdown: Optional list of callables to run at shutdown.
+
+    Yields:
+        A lifespan callable suitable for :class:`~fastapi.FastAPI`.
+    """
+
+    async def _lifespan(app: FastAPI) -> AsyncIterator[None]:
+        # --- Startup ---
+        configure_logging(getattr(settings, "log_level", "INFO"))
+        logger.info("🚀 Agentomatic platform starting...")
+
+        # Discover agents
+        agents_path = Path(agents_dir).resolve()
+        if agents_path.parent not in [Path(p) for p in sys.path]:
+            sys.path.insert(0, str(agents_path.parent))
+
+        registry.discover(agents_path, package_prefix)
+        logger.info(f"📦 {registry.count} agent(s) ready")
+
+        # Custom startup hooks
+        if on_startup:
+            for hook in on_startup:
+                if callable(hook):
+                    result = hook()
+                    if hasattr(result, "__await__"):
+                        await result
+
+        yield
+
+        # --- Shutdown ---
+        logger.info("🛑 Agentomatic platform shutting down...")
+        if on_shutdown:
+            for hook in on_shutdown:
+                if callable(hook):
+                    result = hook()
+                    if hasattr(result, "__await__"):
+                        await result
+
+    yield _lifespan

agentomatic/core/manifest.py

@@ -0,0 +1,100 @@
+"""Agent manifest and registered agent types."""
+
+from __future__ import annotations
+
+from collections.abc import Awaitable, Callable
+from dataclasses import dataclass, field
+from typing import TYPE_CHECKING, Any
+
+if TYPE_CHECKING:
+    from fastapi import APIRouter
+
+    from agentomatic.prompts.manager import PromptManager
+
+
+@dataclass(frozen=True, slots=True)
+class AgentManifest:
+    """Identity card for an agent plugin.
+
+    Every agent must export a ``manifest`` instance in its ``__init__.py``.
+    The registry discovers this automatically.
+
+    Args:
+        name: Short machine name (must match folder name).
+        slug: Full unique identifier (e.g. 'my-platform-agent-holidays').
+        description: Human-readable description.
+        intent_keywords: Keywords for orchestrator intent routing.
+        version: SemVer version string.
+        is_subagent: Whether this agent is routable by an orchestrator.
+        framework: Agent framework type ('langgraph', 'langchain', 'custom').
+        metadata: Arbitrary metadata (used in A2A agent cards).
+    """
+
+    name: str
+    slug: str
+    description: str = ""
+    intent_keywords: list[str] = field(default_factory=list)
+    version: str = "1.0.0"
+    is_subagent: bool = True
+    framework: str = "langgraph"  # 'langgraph' | 'langchain' | 'custom'
+    metadata: dict[str, Any] = field(default_factory=dict)
+
+
+@dataclass(slots=True)
+class RegisteredAgent:
+    """An agent that has been discovered and registered by the platform.
+
+    Contains the manifest, callable functions, and optional enhancements
+    (router, config, prompt manager) discovered from the agent's folder.
+    """
+
+    manifest: AgentManifest
+    node_fn: Callable[..., Awaitable[Any]] | None = None
+    graph_fn: Callable[[], Any] | None = None
+    module_path: str = ""
+
+    # Optional enhancements (populated during discovery)
+    router: APIRouter | None = None
+    config: Any = None
+    prompt_manager: PromptManager | None = None
+
+    @property
+    def name(self) -> str:
+        """Return the agent's short machine name."""
+        return self.manifest.name
+
+    @property
+    def slug(self) -> str:
+        """Return the agent's full unique identifier."""
+        return self.manifest.slug
+
+    async def health_check(self) -> dict[str, Any]:
+        """Check agent health."""
+        result: dict[str, Any] = {
+            "agent": self.name,
+            "slug": self.slug,
+            "version": self.manifest.version,
+            "framework": self.manifest.framework,
+        }
+        # Check node function
+        result["node_fn_ready"] = self.node_fn is not None
+        # Check graph
+        if self.graph_fn:
+            try:
+                graph = self.graph_fn()
+                result["graph_ready"] = graph is not None
+            except Exception as exc:
+                result["graph_ready"] = False
+                result["graph_error"] = str(exc)
+        else:
+            result["graph_ready"] = False
+        # Check prompts
+        if self.prompt_manager:
+            result["prompt_versions"] = self.prompt_manager.list_versions()
+        # Check config
+        result["has_config"] = self.config is not None
+        # Overall status
+        result["status"] = (
+            "healthy" if result.get("node_fn_ready") or result.get("graph_ready") else "degraded"
+        )
+        return result