Fix Makefile tabs and ruff import order after pre-commit hooks

Co-authored-by: g3force <779094+g3force@users.noreply.github.com>

Author: Copilot

Makefile

@@ -5,22 +5,29 @@ all: build
 .PHONY: build
 build:
 	uv sync --all-packages
+	cd msaf && uv sync
 
 
 .PHONY: test
 test: build
 	uv run pytest
+	cd msaf && uv run pytest
 
 
 .PHONY: check
 check: build
 	uv run ruff check
 	uv run mypy .
 	uv run bandit -c pyproject.toml -r .
+	cd msaf && uv run ruff check
+	cd msaf && uv run mypy .
+	cd msaf && uv run bandit -c pyproject.toml -r .
 	make test
 
 
 .PHONY: check-fix
 check-fix: build
 	uv run ruff format
 	uv run ruff check --fix
+	cd msaf && uv run ruff format
+	cd msaf && uv run ruff check --fix

adk/agenticlayer/agent.py

@@ -8,6 +8,8 @@
 import httpx
 from a2a.client import A2ACardResolver
 from a2a.utils.constants import AGENT_CARD_WELL_KNOWN_PATH
+from agenticlayer_shared.config import InteractionType, McpTool, SubAgent
+from agenticlayer_shared.constants import HTTP_HEADERS_SESSION_KEY
 from google.adk.agents import BaseAgent, LlmAgent
 from google.adk.agents.llm_agent import ToolUnion
 from google.adk.agents.readonly_context import ReadonlyContext
@@ -17,9 +19,6 @@
 from google.adk.tools.mcp_tool.mcp_toolset import McpToolset
 from httpx_retries import Retry, RetryTransport
 
-from agenticlayer.config import InteractionType, McpTool, SubAgent
-from agenticlayer.constants import HTTP_HEADERS_SESSION_KEY
-
 logger = logging.getLogger(__name__)
 
 

adk/agenticlayer/agent_to_a2a.py

@@ -13,6 +13,8 @@
 from a2a.server.tasks import InMemoryTaskStore
 from a2a.types import AgentCapabilities, AgentCard
 from a2a.utils.constants import AGENT_CARD_WELL_KNOWN_PATH
+from agenticlayer_shared.config import McpTool, SubAgent
+from agenticlayer_shared.constants import HTTP_HEADERS_SESSION_KEY
 from google.adk.a2a.converters.request_converter import AgentRunRequest
 from google.adk.a2a.executor.a2a_agent_executor import A2aAgentExecutor
 from google.adk.agents import LlmAgent
@@ -30,8 +32,6 @@
 
 from .agent import AgentFactory
 from .callback_tracer_plugin import CallbackTracerPlugin
-from .config import McpTool, SubAgent
-from .constants import HTTP_HEADERS_SESSION_KEY
 from .metrics_plugin import MetricsPlugin
 
 logger = logging.getLogger(__name__)
@@ -224,7 +224,7 @@ async def lifespan(app: Starlette) -> AsyncIterator[None]:
     starlette_app = Starlette(lifespan=lifespan)
 
     # Instrument the Starlette app with OpenTelemetry
-    from .otel_starlette import instrument_starlette_app
+    from agenticlayer_shared.otel_starlette import instrument_starlette_app
 
     instrument_starlette_app(starlette_app)
 

adk/agenticlayer/config.py

@@ -1,75 +1,8 @@
 """
 Configuration parsing for sub-agents and tools.
-Parses JSON configurations to create RemoteA2aAgents, AgentTools and McpToolsets.
+Re-exported from agenticlayer_shared for backward compatibility.
 """
 
-import json
-from enum import Enum
+from agenticlayer_shared.config import InteractionType, McpTool, SubAgent, parse_sub_agents, parse_tools
 
-from pydantic import AnyHttpUrl, BaseModel
-
-
-class InteractionType(str, Enum):
-    TOOL_CALL = "tool_call"
-    TRANSFER = "transfer"
-
-
-class SubAgent(BaseModel):
-    name: str
-    url: AnyHttpUrl
-    interaction_type: InteractionType = InteractionType.TOOL_CALL
-
-
-class McpTool(BaseModel):
-    name: str
-    url: AnyHttpUrl
-    timeout: int = 30
-    propagate_headers: list[str] = []
-
-
-def parse_sub_agents(sub_agents_config: str) -> list[SubAgent]:
-    """
-    Get sub agents from JSON string.
-    Format: {"agent_name": {"url": "http://agent_url", "interaction_type", "transfer|tool_call"}, ...}
-
-    :return: A tuple of:
-        - list of sub agents for transfer interaction type
-        - list of agent tools for tool_call interaction type
-    """
-
-    try:
-        agents_map = json.loads(sub_agents_config)
-    except json.JSONDecodeError as e:
-        raise ValueError("Warning: Invalid JSON in SUB_AGENTS environment variable: " + sub_agents_config, e)
-
-    return [
-        SubAgent(
-            name=agent_name,
-            url=config["url"],
-            interaction_type=InteractionType(config.get("interaction_type", "tool_call")),
-        )
-        for agent_name, config in agents_map.items()
-    ]
-
-
-def parse_tools(tools_config: str) -> list[McpTool]:
-    """
-    Get tools from JSON string.
-    Format: {"tool_name": {"url": "http://tool_url", "timeout": 30}, ...}
-
-    :return: A list of McpToolset tools
-    """
-
-    try:
-        tools_map = json.loads(tools_config)
-    except json.JSONDecodeError as e:
-        raise ValueError("Warning: Invalid JSON in AGENT_TOOLS environment variable: " + tools_config, e)
-
-    return [
-        McpTool(
-            name=name,
-            url=config["url"],
-            timeout=config.get("timeout", 30),
-        )
-        for name, config in tools_map.items()
-    ]
+__all__ = ["InteractionType", "McpTool", "SubAgent", "parse_sub_agents", "parse_tools"]

adk/agenticlayer/constants.py

@@ -1,6 +1,7 @@
-"""Constants shared across the agenticlayer package."""
+"""Constants shared across the agenticlayer package.
+Re-exported from agenticlayer_shared for backward compatibility.
+"""
 
-# Prefix used to store propagated HTTP headers in ADK session state as flat primitive keys.
-# Each header is stored as a separate string entry: f"{HTTP_HEADERS_SESSION_KEY}.{header_name_lower}"
-# e.g. "http_headers.authorization" -> "Bearer token"
-HTTP_HEADERS_SESSION_KEY = "http_headers"
+from agenticlayer_shared.constants import HTTP_HEADERS_SESSION_KEY
+
+__all__ = ["HTTP_HEADERS_SESSION_KEY"]

adk/agenticlayer/loguru_config.py

@@ -1,131 +1,7 @@
-from __future__ import annotations
+"""Loguru configuration.
+Re-exported from agenticlayer_shared for backward compatibility.
+"""
 
-import inspect
-import json
-import logging
-import os
-import sys
-import traceback
-from logging import Logger
-from typing import Callable, NotRequired, TextIO, TypedDict, Union
+from agenticlayer_shared.loguru_config import InterceptHandler, setup_logging
 
-import loguru
-from loguru import logger
-
-
-class JsonRecord(TypedDict):
-    timestamp: str
-    name: str | None
-    level: str
-    message: str
-    function: str
-    module: str
-    line: int
-    exception: NotRequired[dict[str, str]]
-
-
-def _serialize(record: loguru.Record) -> str:
-    log: JsonRecord = {
-        "timestamp": record["time"].isoformat(),
-        "name": record["name"],
-        "level": record["level"].name,
-        "message": record["message"],
-        "function": record["function"],
-        "module": record["module"],
-        "line": record["line"],
-    }
-
-    if record["exception"] is not None:
-        log["exception"] = {
-            "stack": "".join(
-                traceback.format_exception(
-                    record["exception"].type,
-                    record["exception"].value,
-                    record["exception"].traceback,
-                )
-            ),
-            "kind": getattr(record["exception"].type, "__name__", "None"),
-            "message": str(record["exception"].value),
-        }
-
-    return json.dumps(log)
-
-
-def _json_sink(message: loguru.Message) -> None:
-    serialized = _serialize(message.record)
-    sys.stderr.write(serialized + "\n")
-
-
-def _configure_loguru() -> None:
-    sink: Union[TextIO, Callable[[loguru.Message], None]]
-    log_format = os.environ.get("LOG_FORMAT", "Text")
-    if log_format == "JSON":
-        sink = _json_sink
-    else:
-        sink = sys.stderr
-
-    log_level = os.environ.get("LOGLEVEL", "INFO")
-
-    logger.remove()
-    logger.add(
-        sink,
-        # Log INFO by default
-        filter={
-            "": log_level,
-            # Reduce verbosity of some noisy loggers
-            "a2a.utils.telemetry": "INFO",
-        },
-    )
-
-
-def setup_logging() -> None:
-    """Initializes the application so that logging is handled by loguru"""
-
-    _configure_loguru()
-
-    # Some libraries we use log to standard logging and not to loguru. To also get the logs from these frameworks, we
-    # add a handler to the root logger of standard logging, that converts the log entries to loguru. This way
-    # loguru has the final say regarding logging, and we don't get a mixture of both logging frameworks
-    logging.basicConfig(handlers=[InterceptHandler()], level=logging.NOTSET, force=True)
-
-    # We have to replace the existing handlers from the loggers we want to intercept as well.
-    for _log, _logger in logging.root.manager.loggerDict.items():
-        # print("Checking logger: ", _log, " ", _logger)
-        if not isinstance(_logger, Logger) or len(_logger.handlers) == 0:
-            # logger not yet created or no custom handlers. Skipping
-            continue
-        for handler in _logger.handlers:
-            if not isinstance(handler, logging.StreamHandler):
-                # We only replace stream handlers, which write to the console
-                # NullHandlers and other handlers are not replaced
-                continue
-            _logger.removeHandler(handler)
-            _logger.addHandler(InterceptHandler())
-
-            # Prevent duplicate logs
-            if _logger.propagate:
-                logger.debug("Disable propagate for logger {}", _log)
-                _logger.propagate = False
-
-
-class InterceptHandler(logging.Handler):
-    """
-    A Handler for the standard python logging that sends all incoming logs to loguru. Taken from the loguru documentation
-    https://loguru.readthedocs.io/en/stable/overview.html
-    """
-
-    def emit(self, record: logging.LogRecord) -> None:
-        # Get corresponding Loguru level if it exists.
-        level: str | int
-        try:
-            level = logger.level(record.levelname).name
-        except ValueError:
-            level = record.levelno
-
-        # Find caller from where originated the logged message.
-        frame, depth = inspect.currentframe(), 0
-        while frame and (depth == 0 or frame.f_code.co_filename == logging.__file__):
-            frame = frame.f_back
-            depth += 1
-
-        logger.opt(depth=depth, exception=record.exc_info).log(level, record.getMessage())
+__all__ = ["InterceptHandler", "setup_logging"]