naas-abi-core 1.4.1__py3-none-any.whl

naas_abi_core/__init__.py

@@ -0,0 +1 @@
+from naas_abi_core.utils.Logger import logger as logger

naas_abi_core/apps/api/api.py

@@ -0,0 +1,245 @@
+import os
+import subprocess
+from typing import Annotated, Optional
+
+from fastapi import APIRouter, Depends, FastAPI, HTTPException, Request, status
+from fastapi.middleware.cors import CORSMiddleware
+from fastapi.openapi.docs import get_redoc_html, get_swagger_ui_html
+from fastapi.openapi.models import OAuthFlowPassword
+from fastapi.openapi.models import OAuthFlows as OAuthFlowsModel
+from fastapi.openapi.utils import get_openapi
+from fastapi.responses import HTMLResponse
+
+# Authentication
+from fastapi.security import OAuth2PasswordRequestForm
+from fastapi.security.oauth2 import OAuth2
+from fastapi.security.utils import get_authorization_scheme_param
+from fastapi.staticfiles import StaticFiles
+from naas_abi_core import logger
+from importlib.resources import files
+
+# Docs
+from naas_abi_core.apps.api.openapi_doc import API_LANDING_HTML, TAGS_METADATA
+from naas_abi_core.engine.Engine import Engine
+
+engine = Engine()
+engine.load()
+
+# Init API
+TITLE = engine.configuration.api.title
+DESCRIPTION = engine.configuration.api.description
+app = FastAPI(title=TITLE, docs_url=None, redoc_url=None)
+
+# Set logo path
+logo_path = engine.configuration.api.logo_path
+logo_name = os.path.basename(logo_path)
+
+# Set favicon path
+favicon_path = engine.configuration.api.favicon_path
+favicon_name = os.path.basename(favicon_path)
+
+origins = engine.configuration.api.cors_origins
+
+logger.debug(f"CORS origins: {origins}")
+
+app.add_middleware(
+    CORSMiddleware,
+    allow_origins=origins,
+    allow_credentials=True,
+    allow_methods=["*"],
+    allow_headers=["*"],
+)
+
+
+static_dir = os.path.join(os.path.dirname(str(files("naas_abi_core"))), "assets")
+app.mount("/static", StaticFiles(directory=str(static_dir)), name="static")
+
+
+
+# Custom OAuth2 class that accepts query parameter
+class OAuth2QueryBearer(OAuth2):
+    def __init__(
+        self,
+        tokenUrl: str,
+        scheme_name: Optional[str] = None,
+        auto_error: bool = True,
+    ):
+        flows = OAuthFlowsModel(password=OAuthFlowPassword(tokenUrl=tokenUrl))
+        super().__init__(flows=flows, scheme_name=scheme_name, auto_error=auto_error)
+
+    async def __call__(self, request: Request) -> Optional[str]:
+        authorization = request.headers.get("Authorization")
+        # Check header first
+        if authorization:
+            scheme, header_token = get_authorization_scheme_param(authorization)
+            if scheme.lower() == "bearer" and header_token:
+                return header_token
+
+        # Then check query parameter
+        query_token = request.query_params.get("token")
+        if query_token:
+            return query_token
+
+        # No token found in either place
+        if self.auto_error:
+            raise HTTPException(
+                status_code=status.HTTP_401_UNAUTHORIZED,
+                detail="Not authenticated",
+                headers={"WWW-Authenticate": "Bearer"},
+            )
+        return None
+
+
+# Replace the existing oauth2_scheme with:
+oauth2_scheme = OAuth2QueryBearer(tokenUrl="token")
+
+
+# Update the token validation dependency
+async def is_token_valid(token: str = Depends(oauth2_scheme)):
+    if token != os.environ.get("ABI_API_KEY"):
+        raise HTTPException(
+            status_code=status.HTTP_401_UNAUTHORIZED,
+            detail="Invalid authentication credentials",
+            headers={"WWW-Authenticate": "Bearer"},
+        )
+    return True
+
+
+@app.post("/token", include_in_schema=False)
+async def login(form_data: Annotated[OAuth2PasswordRequestForm, Depends()]):
+    if form_data.password != "abi":
+        raise HTTPException(status_code=400, detail="Incorrect username or password")
+
+    return {"access_token": "abi", "token_type": "bearer"}
+
+
+# Create Agents API Router
+agents_router = APIRouter(
+    prefix="/agents",
+    tags=["Agents"],
+    responses={401: {"description": "Unauthorized"}},
+    dependencies=[Depends(is_token_valid)],  # Apply token verification
+)
+
+# Create Pipelines API Router
+pipelines_router = APIRouter(
+    prefix="/pipelines",
+    tags=["Pipelines"],
+    responses={401: {"description": "Unauthorized"}},
+    dependencies=[Depends(is_token_valid)],  # Apply token verification
+)
+
+# Create Pipelines API Router
+workflows_router = APIRouter(
+    prefix="/workflows",
+    tags=["Workflows"],
+    responses={401: {"description": "Unauthorized"}},
+    dependencies=[Depends(is_token_valid)],  # Apply token verification
+)
+
+
+def get_git_tag():
+    try:
+        tag = subprocess.check_output(["git", "describe", "--tags"]).strip().decode()
+    except Exception as _:
+        # if file VERSION exists, use it
+        if os.path.exists("VERSION"):
+            with open("VERSION", "r") as f:
+                tag = f.read().strip()
+        else:
+            tag = "v0.0.1"
+    return tag
+
+
+def custom_openapi():
+    if app.openapi_schema:
+        return app.openapi_schema
+    openapi_schema = get_openapi(
+        title=TITLE,
+        description=DESCRIPTION,
+        version=get_git_tag(),
+        routes=app.routes,
+        tags=TAGS_METADATA,
+    )
+    openapi_schema["info"]["x-logo"] = {
+        "url": f"/static/{logo_name}",
+        "altText": "Logo",
+    }
+    app.openapi_schema = openapi_schema
+    return app.openapi_schema
+
+
+app.openapi = custom_openapi  # type: ignore[method-assign]
+
+
+@app.get("/docs", include_in_schema=False)
+def overridden_swagger():
+    return get_swagger_ui_html(
+        openapi_url="/openapi.json",
+        title=TITLE,
+        swagger_favicon_url=f"/static/{favicon_name}",
+    )
+
+
+@app.get("/redoc", include_in_schema=False)
+def overridden_redoc():
+    return get_redoc_html(
+        openapi_url="/openapi.json",
+        title=TITLE,
+        redoc_favicon_url=f"/static/{favicon_name}",
+    )
+
+
+@app.get("/", response_class=HTMLResponse, include_in_schema=False)
+def root():
+    return API_LANDING_HTML.replace("[TITLE]", TITLE).replace("[LOGO_NAME]", logo_name)
+
+
+# Add agents to the API
+all_agents: list = []
+for module in engine.modules.values():
+    for agent in module.agents:
+        if agent is not None:
+            all_agents.append(agent.New())
+        else:
+            logger.warning(f"Skipping {agent.name} agent (missing API key)")
+
+# Sort agents by name and add to router
+for agent in sorted(all_agents, key=lambda a: a.name):
+    logger.debug(f"Adding agent to API: {agent.name}")
+    agent.as_api(agents_router)
+
+# Include routers
+app.include_router(agents_router)
+app.include_router(pipelines_router)
+app.include_router(workflows_router)
+
+
+def api():
+    import uvicorn
+
+    if os.environ.get("ENV") == "dev":
+        uvicorn.run(
+            "naas_abi_core.apps.api.api:app",
+            host="0.0.0.0",
+            port=9879,
+            reload=os.environ.get("ENV") == "dev",
+            reload_dirs=["src", "lib"],
+            log_level="debug",
+        )
+    else:
+        uvicorn.run(app, host="0.0.0.0", port=9879)
+
+
+def test_init():
+    logger.info("✅ API initialization completed successfully")
+    print("API_INIT_TEST_PASSED")
+
+
+if __name__ == "__main__":
+    import sys
+
+    if "--test-init" in sys.argv or os.environ.get("TEST_INIT") == "true":
+        test_init()
+    else:
+        api()

naas_abi_core/apps/api/api_test.py

@@ -0,0 +1,281 @@
+import os
+
+import pytest
+from fastapi.testclient import TestClient
+
+
+def test_import_fastapi_app():
+    """Test that we can import the FastAPI app from naas_abi.api."""
+    try:
+        from naas_abi_core.apps.api.api import app
+
+        assert app is not None
+        assert hasattr(app, "title")
+        print(f"✅ Successfully imported FastAPI app with title: {app.title}")
+    except Exception as e:
+        pytest.fail(f"Failed to import FastAPI app: {e}")
+
+
+def test_api_basic_endpoints():
+    """Test basic endpoints of the API."""
+    try:
+        from naas_abi_core.apps.api.api import app
+
+        client = TestClient(app)
+
+        # Test root endpoint
+        response = client.get("/")
+        assert response.status_code == 200
+        print("✅ API root endpoint works")
+
+        # Test docs endpoint
+        response = client.get("/docs")
+        assert response.status_code == 200
+        print("✅ API docs endpoint works")
+
+        # Test redoc endpoint
+        response = client.get("/redoc")
+        assert response.status_code == 200
+        print("✅ API redoc endpoint works")
+
+        # Test OpenAPI schema
+        response = client.get("/openapi.json")
+        assert response.status_code == 200
+        schema = response.json()
+        assert "openapi" in schema
+        assert "info" in schema
+        print("✅ API OpenAPI schema works")
+
+    except Exception as e:
+        pytest.fail(f"Failed to test API basic endpoints: {e}")
+
+
+def test_api_authentication():
+    """Test authentication endpoints of the API."""
+    try:
+        from naas_abi_core.apps.api.api import app
+
+        client = TestClient(app)
+
+        # Test token endpoint with valid credentials
+        response = client.post("/token", data={"username": "user", "password": "abi"})
+        assert response.status_code == 200
+        data = response.json()
+        assert data["access_token"] == "abi"
+        assert data["token_type"] == "bearer"
+        print("✅ API authentication with valid credentials works")
+
+        # Test token endpoint with invalid credentials
+        response = client.post("/token", data={"username": "user", "password": "wrong"})
+        assert response.status_code == 400
+        print("✅ API properly rejects invalid credentials")
+
+    except Exception as e:
+        pytest.fail(f"Failed to test API authentication: {e}")
+
+
+def test_api_agent_routes():
+    """Test that each agent has both /completion and /stream-completion endpoints."""
+    try:
+        from fastapi import APIRouter
+        from naas_abi_core.apps.api.api import app, engine
+
+        client = TestClient(app)
+
+        modules = engine.modules.values()
+
+        # Get OpenAPI schema to check routes
+        response = client.get("/openapi.json")
+        assert response.status_code == 200
+        schema = response.json()
+
+        paths = schema.get("paths", {})
+
+        # Look for agent routes
+        agent_routes = [path for path in paths.keys() if path.startswith("/agents/")]
+
+        print(f"📊 Found {len(agent_routes)} agent routes in API:")
+        for route in sorted(agent_routes):
+            print(f"  {route}")
+
+        # Get loaded modules and agents
+        loaded_modules = modules
+        total_agents = 0
+        agents_with_routes = {}
+
+        print("\n📦 Loaded modules and their agents:")
+        for module in loaded_modules:
+            print(f"Module: {module.module_import_path}")
+            print(f"Agents: {module.agents}")
+            for agent in module.agents:
+                # Skip None agents (when API keys are missing)
+                if agent is not None:
+                    total_agents += 1
+
+                    # Create a temporary router to inspect what routes the agent would add
+                    temp_router = APIRouter()
+                    agent.as_api(temp_router)
+
+                    # Extract route paths from the temporary router
+                    agent_route_paths = []
+                    for route in temp_router.routes:
+                        if hasattr(route, "path"):
+                            agent_route_paths.append(route.path)
+
+                    agents_with_routes[agent.name] = agent_route_paths
+                    print(f"  🤖 Agent: {agent.name} (routes: {agent_route_paths})")
+                else:
+                    print("  ⚠️ Skipped None agent (missing API key)")
+
+        print("\n📈 Summary:")
+        print(f"  - Total modules loaded: {len(loaded_modules)}")
+        print(f"  - Total agents loaded: {total_agents}")
+        print(f"  - Total agent routes in API: {len(agent_routes)}")
+
+        # Verify we have some structure
+        assert len(paths) > 0, f"No API paths found in the OpenAPI schema: {paths}"
+        assert len(loaded_modules) > 0, f"No modules loaded: {loaded_modules}"
+
+        # Check that each agent has both required endpoints
+        if total_agents > 0:
+            # # We expect at least 2 routes per agent (completion and stream-completion)
+            # assert len(agent_routes) >= 2 * total_agents, \
+            #     f"Expected at least {2 * total_agents} routes for {total_agents} agents, but found {len(agent_routes)}"
+
+            # Check each agent has routes ending with /completion and /stream-completion
+            agents_missing_routes = []
+            agents_with_both_routes = []
+
+            for agent_name, route_paths in agents_with_routes.items():
+                has_completion = False
+                has_stream = False
+
+                # Check in the actual API paths (with /agents prefix)
+                for path in paths.keys():
+                    if path.startswith("/agents/"):
+                        if path.endswith("/completion"):
+                            has_completion = True
+                        elif path.endswith("/stream-completion"):
+                            has_stream = True
+
+                if has_completion and has_stream:
+                    agents_with_both_routes.append(agent_name)
+                else:
+                    missing = []
+                    if not has_completion:
+                        missing.append("completion")
+                    if not has_stream:
+                        missing.append("stream-completion")
+                    agents_missing_routes.append((agent_name, missing))
+
+            print("\n🔍 Route validation:")
+            print(
+                f"  - Agents with both endpoints: {len(agents_with_both_routes)}/{total_agents}"
+            )
+            print(
+                f"  - Agents missing endpoints: {len(agents_missing_routes)}/{total_agents}"
+            )
+
+            # assert total_agents == len(agents_with_both_routes) + len(agents_missing_routes), f"Expected {total_agents} agents, but found {len(agents_with_both_routes) + len(agents_missing_routes)}"
+
+            if agents_with_both_routes:
+                print("  ✅ Agents with both endpoints:")
+                for agent in agents_with_both_routes[:5]:  # Show first 5
+                    print(f"    - {agent}")
+
+            if agents_missing_routes:
+                print("  ❌ Agents missing endpoints:")
+                for agent, missing in agents_missing_routes[:5]:  # Show first 5
+                    print(f"    - {agent}: missing {', '.join(missing)}")
+                pytest.fail(
+                    f"{len(agents_missing_routes)} agents are missing required endpoints"
+                )
+
+            print(
+                "✅ All agents have both /completion and /stream-completion endpoints"
+            )
+        else:
+            print("⚠️ No agents were loaded, so no agent routes expected")
+
+    except Exception as e:
+        pytest.fail(f"Failed to test API agent routes: {e}")
+
+
+def test_api_protected_routes():
+    """Test that protected routes require authentication."""
+    try:
+        from naas_abi_core.apps.api.api import app
+
+        client = TestClient(app)
+
+        # Get available agent routes first
+        response = client.get("/openapi.json")
+        schema = response.json()
+        paths = schema.get("paths", {})
+        agent_routes = [
+            path
+            for path in paths.keys()
+            if path.startswith("/agents/") and not path.endswith("/stream-completion")
+        ]
+
+        if agent_routes:
+            # Test first agent route without authentication
+            test_route = agent_routes[0]
+            response = client.get(test_route)
+
+            # Should be 401 (unauthorized) or 405 (method not allowed for GET on POST endpoint)
+            # Many agent routes are POST endpoints, so GET might return 405
+            assert response.status_code in [401, 404, 405], (
+                f"Expected 401, 404, or 405 but got {response.status_code}"
+            )
+            print(
+                f"✅ Route {test_route} properly requires authentication or correct method"
+            )
+
+            # Test with valid authentication header
+            headers = {"Authorization": f"Bearer {os.getenv('ABI_API_KEY', 'abi')}"}
+            response = client.get(test_route, headers=headers)
+
+            # Should still be 405 if it's a POST endpoint, or 422 if it needs request body
+            assert response.status_code in [401, 404, 405, 422], (
+                f"Route behavior: {response.status_code}"
+            )
+            print(f"✅ Route {test_route} responds appropriately with auth header")
+        else:
+            print("⚠️ No agent routes found to test authentication")
+
+    except Exception as e:
+        pytest.fail(f"Failed to test API protected routes: {e}")
+
+
+def test_api_cors_configuration():
+    """Test CORS configuration of the API."""
+    try:
+        from naas_abi_core.apps.api.api import app
+
+        client = TestClient(app)
+
+        # Test CORS headers with origin
+        response = client.get("/", headers={"Origin": "http://localhost:9879"})
+        assert response.status_code == 200
+
+        # Check for CORS headers
+        headers = response.headers
+        cors_headers = [
+            h for h in headers.keys() if h.lower().startswith("access-control")
+        ]
+
+        if cors_headers:
+            print(f"✅ CORS headers found: {cors_headers}")
+        else:
+            # CORS headers might not appear on simple requests
+            print("⚠️ No CORS headers found (may be normal for simple requests)")
+
+        print("✅ API CORS configuration tested")
+
+    except Exception as e:
+        pytest.fail(f"Failed to test API CORS: {e}")
+
+
+if __name__ == "__main__":
+    pytest.main([__file__, "-v", "-s"])

naas_abi_core/apps/api/openapi_doc.py

@@ -0,0 +1,144 @@
+TAGS_METADATA = [
+    {
+        "name": "Overview",
+        "description": """
+### Project Overview
+The **ABI** (Artificial Business Intelligence) project is a Python-based backend framework designed to serve as the core infrastructure for building an Organizational AI System. 
+This system empowers businesses to integrate, manage, and scale AI-driven operations with a focus on ontology, assistant-driven workflows, and analytics.\n
+Designed for flexibility and scalability, ABI provides a customizable framework suitable for organizations aiming to create intelligent, automated systems tailored to their needs.
+
+### API Overview
+The ABI API allows users and applications to interact with ABI's capabilities for business process automation and intelligence.\n
+This document describes the current version of the ABI API, which provides access to agents, pipelines, workflows, integrations, ontology management and analytics features.
+        """,
+    },
+    {
+        "name": "Authentication",
+        "description": """
+Authentication uses a Bearer token that can be provided either in the Authorization header (e.g. 'Authorization: Bearer `<token>`') or as a query parameter (e.g. '?token=`<token>`'). 
+The token must match the `ABI_API_KEY` environment variable.
+Contact your administrator to get the token.
+
+*Authentication with Authorization header:*
+
+```python
+import requests
+
+url = "https://<your-registry-name>.default.space.naas.ai/agents/abi/completion"
+
+headers = {
+    "Authorization": f"Bearer {token}"
+}
+
+response = requests.post(url, headers=headers)
+print(response.json())
+```
+
+*Authentication with query parameter:*
+
+```python
+import requests
+
+url = "https://<your-registry-name>.default.space.naas.ai/agents/abi/completion?token=<token>"
+
+response = requests.post(url)
+print(response.json())
+```
+        """,
+    },
+    {
+        "name": "Agents",
+        "description": """
+API endpoints for interacting with ABI's agents.
+
+### Core Agents:
+- Abi: Manages and coordinates other agents
+- Ontology: Manages and coordinates other agents
+- Naas: Manages and coordinates other agents
+- Support: Provides help and guidance for using ABI
+
+### Marketplace Agents:
+- Custom agents with deep expertise in specific domains
+- Can be configured and trained for specialized tasks
+- Extensible through custom tools and knowledge bases
+
+Each agent can be accessed through dedicated endpoints that allow:
+- Completion requests for generating responses
+- Chat interactions for ongoing conversations
+- Tool execution for specific tasks
+- Configuration updates for customizing behavior
+
+Agents leverage various tools including integrations, pipelines and workflows to accomplish tasks. They can be extended with custom tools and knowledge to enhance their capabilities.
+
+        """,
+    },
+    {
+        "name": "Pipelines",
+        "description": """
+API endpoints for interacting with ABI's pipelines.
+        """,
+    },
+    {
+        "name": "Workflows",
+        "description": """
+API endpoints for interacting with ABI's workflows.
+        """,
+    },
+]
+
+API_LANDING_HTML = """
+<!DOCTYPE html>
+<html>
+    <head>
+        <title>[TITLE]</title>
+        <link rel="icon" type="image/x-icon" href="/static/favicon.ico">
+        <style>
+            body {
+                font-family: Arial, sans-serif;
+                display: flex;
+                flex-direction: column;
+                align-items: center;
+                justify-content: center;
+                height: 100vh;
+                margin: 0;
+                background-color: #000000;
+                color: white;
+            }
+            .logo {
+                width: 200px;
+                margin-bottom: 20px;
+            }
+            h1 {
+                font-size: 48px;
+                margin-bottom: 40px;
+            }
+            .buttons {
+                display: flex;
+                gap: 20px;
+            }
+            a {
+                padding: 12px 24px;
+                font-size: 18px;
+                border: none;
+                border-radius: 4px;
+                cursor: pointer;
+                text-decoration: none;
+                color: white;
+                background-color: #007bff;
+                transition: background-color 0.2s;
+            }
+            a:hover {
+                background-color: #0056b3;
+            }
+        </style>
+    </head>
+    <body>
+        <img src="/static/[LOGO_NAME]" alt="Logo" class="logo">
+        <h1>Welcome to [TITLE]!</h1>
+        <p>[TITLE] is a tool that allows you to interact with ABI's capabilities for business process automation and intelligence.</p>
+        <div class="buttons">
+            <a href="/redoc">Go to Documentation</a>
+        </div>
+    </body>
+</html>
+"""