agentic-layer-sdk-msaf 0.13.0__tar.gz

agentic_layer_sdk_msaf-0.13.0/.gitignore

@@ -0,0 +1,207 @@
+# Byte-compiled / optimized / DLL files
+__pycache__/
+*.py[codz]
+*$py.class
+
+# C extensions
+*.so
+
+# Distribution / packaging
+.Python
+build/
+develop-eggs/
+dist/
+downloads/
+eggs/
+.eggs/
+lib/
+lib64/
+parts/
+sdist/
+var/
+wheels/
+share/python-wheels/
+*.egg-info/
+.installed.cfg
+*.egg
+MANIFEST
+
+# PyInstaller
+#  Usually these files are written by a python script from a template
+#  before PyInstaller builds the exe, so as to inject date/other infos into it.
+*.manifest
+*.spec
+
+# Installer logs
+pip-log.txt
+pip-delete-this-directory.txt
+
+# Unit test / coverage reports
+htmlcov/
+.tox/
+.nox/
+.coverage
+.coverage.*
+.cache
+nosetests.xml
+coverage.xml
+*.cover
+*.py.cover
+.hypothesis/
+.pytest_cache/
+cover/
+
+# Translations
+*.mo
+*.pot
+
+# Django stuff:
+*.log
+local_settings.py
+db.sqlite3
+db.sqlite3-journal
+
+# Flask stuff:
+instance/
+.webassets-cache
+
+# Scrapy stuff:
+.scrapy
+
+# Sphinx documentation
+docs/_build/
+
+# PyBuilder
+.pybuilder/
+target/
+
+# Jupyter Notebook
+.ipynb_checkpoints
+
+# IPython
+profile_default/
+ipython_config.py
+
+# pyenv
+#   For a library or package, you might want to ignore these files since the code is
+#   intended to run in multiple environments; otherwise, check them in:
+# .python-version
+
+# pipenv
+#   According to pypa/pipenv#598, it is recommended to include Pipfile.lock in version control.
+#   However, in case of collaboration, if having platform-specific dependencies or dependencies
+#   having no cross-platform support, pipenv may install dependencies that don't work, or not
+#   install all needed dependencies.
+#Pipfile.lock
+
+# UV
+#   Similar to Pipfile.lock, it is generally recommended to include uv.lock in version control.
+#   This is especially recommended for binary packages to ensure reproducibility, and is more
+#   commonly ignored for libraries.
+#uv.lock
+
+# poetry
+#   Similar to Pipfile.lock, it is generally recommended to include poetry.lock in version control.
+#   This is especially recommended for binary packages to ensure reproducibility, and is more
+#   commonly ignored for libraries.
+#   https://python-poetry.org/docs/basic-usage/#commit-your-poetrylock-file-to-version-control
+#poetry.lock
+#poetry.toml
+
+# pdm
+#   Similar to Pipfile.lock, it is generally recommended to include pdm.lock in version control.
+#   pdm recommends including project-wide configuration in pdm.toml, but excluding .pdm-python.
+#   https://pdm-project.org/en/latest/usage/project/#working-with-version-control
+#pdm.lock
+#pdm.toml
+.pdm-python
+.pdm-build/
+
+# pixi
+#   Similar to Pipfile.lock, it is generally recommended to include pixi.lock in version control.
+#pixi.lock
+#   Pixi creates a virtual environment in the .pixi directory, just like venv module creates one
+#   in the .venv directory. It is recommended not to include this directory in version control.
+.pixi
+
+# PEP 582; used by e.g. github.com/David-OConnor/pyflow and github.com/pdm-project/pdm
+__pypackages__/
+
+# Celery stuff
+celerybeat-schedule
+celerybeat.pid
+
+# SageMath parsed files
+*.sage.py
+
+# Environments
+.env
+.envrc
+.venv
+env/
+venv/
+ENV/
+env.bak/
+venv.bak/
+
+# Spyder project settings
+.spyderproject
+.spyproject
+
+# Rope project settings
+.ropeproject
+
+# mkdocs documentation
+/site
+
+# mypy
+.mypy_cache/
+.dmypy.json
+dmypy.json
+
+# Pyre type checker
+.pyre/
+
+# pytype static type analyzer
+.pytype/
+
+# Cython debug symbols
+cython_debug/
+
+# PyCharm
+#  JetBrains specific template is maintained in a separate JetBrains.gitignore that can
+#  be found at https://github.com/github/gitignore/blob/main/Global/JetBrains.gitignore
+#  and can be added to the global gitignore or merged into this file.  For a more nuclear
+#  option (not recommended) you can uncomment the following to ignore the entire idea folder.
+.idea/
+
+# Abstra
+# Abstra is an AI-powered process automation framework.
+# Ignore directories containing user credentials, local state, and settings.
+# Learn more at https://abstra.io/docs
+.abstra/
+
+# Visual Studio Code
+#  Visual Studio Code specific template is maintained in a separate VisualStudioCode.gitignore
+#  that can be found at https://github.com/github/gitignore/blob/main/Global/VisualStudioCode.gitignore
+#  and can be added to the global gitignore or merged into this file. However, if you prefer,
+#  you could uncomment the following to ignore the entire vscode folder
+# .vscode/
+
+# Ruff stuff:
+.ruff_cache/
+
+# PyPI configuration file
+.pypirc
+
+# Cursor
+#  Cursor is an AI-powered code editor. `.cursorignore` specifies files/directories to
+#  exclude from AI features like autocomplete and code analysis. Recommended for sensitive data
+#  refer to https://docs.cursor.com/context/ignore-files
+.cursorignore
+.cursorindexingignore
+
+# Marimo
+marimo/_static/
+marimo/_lsp/
+__marimo__/

agentic_layer_sdk_msaf-0.13.0/Makefile

@@ -0,0 +1,26 @@
+.PHONY: all
+all: build
+
+
+.PHONY: build
+build:
+	uv sync
+
+
+.PHONY: test
+test: build
+	uv run pytest
+
+
+.PHONY: check
+check: build
+	uv run ruff check
+	uv run mypy --no-incremental .
+	uv run bandit -c pyproject.toml -r .
+	make test
+
+
+.PHONY: check-fix
+check-fix: build
+	uv run ruff format
+	uv run ruff check --fix

agentic_layer_sdk_msaf-0.13.0/PKG-INFO

@@ -0,0 +1,49 @@
+Metadata-Version: 2.4
+Name: agentic-layer-sdk-msaf
+Version: 0.13.0
+Requires-Python: <3.15,>=3.14
+Requires-Dist: a2a-sdk
+Requires-Dist: agent-framework-core>=1.0.0rc2
+Requires-Dist: agentic-layer-sdk-shared
+Requires-Dist: httpx
+Requires-Dist: httpx-retries>=0.4.5
+Requires-Dist: starlette
+Description-Content-Type: text/markdown
+
+# agentic-layer-sdk-msaf
+
+Microsoft Agent Framework adapter for the Agentic Layer SDK.
+
+This package provides utilities to convert a [Microsoft Agent Framework](https://github.com/microsoft/agent-framework) agent into an instrumented A2A Starlette web application.
+
+## Usage
+
+```python
+from agent_framework import Agent
+from agenticlayer.msaf.agent_to_a2a import to_a2a
+from agenticlayer.msaf.client import create_openai_client
+
+agent = Agent(
+    client=create_openai_client(),
+    name="MyAgent",
+    instructions="You are a helpful assistant.",
+)
+app = to_a2a(agent, name="MyAgent", rpc_url="http://localhost:8000/")
+# Then run with: uvicorn module:app
+```
+
+## Configuration
+
+### OpenAI-compatible gateway (LiteLLM proxy)
+
+Set the following environment variables to point the agent at an OpenAI-compatible gateway
+such as [LiteLLM proxy](https://docs.litellm.ai/docs/proxy/quick_start):
+
+| Variable | Description |
+|---|---|
+| `LITELLM_PROXY_API_BASE` | Base URL of the gateway, e.g. `http://litellm-proxy:4000` |
+| `LITELLM_PROXY_API_KEY` | API key for the gateway |
+| `OPENAI_CHAT_MODEL_ID` | Model name to use, e.g. `gpt-4o` |
+
+`create_openai_client()` reads these variables automatically and passes them to
+`OpenAIChatClient` as `base_url` and `api_key`.

agentic_layer_sdk_msaf-0.13.0/README.md

@@ -0,0 +1,37 @@
+# agentic-layer-sdk-msaf
+
+Microsoft Agent Framework adapter for the Agentic Layer SDK.
+
+This package provides utilities to convert a [Microsoft Agent Framework](https://github.com/microsoft/agent-framework) agent into an instrumented A2A Starlette web application.
+
+## Usage
+
+```python
+from agent_framework import Agent
+from agenticlayer.msaf.agent_to_a2a import to_a2a
+from agenticlayer.msaf.client import create_openai_client
+
+agent = Agent(
+    client=create_openai_client(),
+    name="MyAgent",
+    instructions="You are a helpful assistant.",
+)
+app = to_a2a(agent, name="MyAgent", rpc_url="http://localhost:8000/")
+# Then run with: uvicorn module:app
+```
+
+## Configuration
+
+### OpenAI-compatible gateway (LiteLLM proxy)
+
+Set the following environment variables to point the agent at an OpenAI-compatible gateway
+such as [LiteLLM proxy](https://docs.litellm.ai/docs/proxy/quick_start):
+
+| Variable | Description |
+|---|---|
+| `LITELLM_PROXY_API_BASE` | Base URL of the gateway, e.g. `http://litellm-proxy:4000` |
+| `LITELLM_PROXY_API_KEY` | API key for the gateway |
+| `OPENAI_CHAT_MODEL_ID` | Model name to use, e.g. `gpt-4o` |
+
+`create_openai_client()` reads these variables automatically and passes them to
+`OpenAIChatClient` as `base_url` and `api_key`.

agentic_layer_sdk_msaf-0.13.0/agenticlayer/msaf/__init__.py

@@ -0,0 +1,9 @@
+"""
+Microsoft Agent Framework adapter for the Agentic Layer SDK.
+Provides utilities to convert a Microsoft agent-framework Agent into
+an instrumented A2A Starlette web application.
+"""
+
+from agenticlayer.msaf.client import create_openai_client
+
+__all__ = ["create_openai_client"]

agentic_layer_sdk_msaf-0.13.0/agenticlayer/msaf/agent.py

@@ -0,0 +1,145 @@
+"""
+Convert Sub Agents and Tools into agent-framework FunctionTools and MCPStreamableHTTPTools.
+"""
+
+import logging
+from typing import Any
+
+import httpx
+from a2a.client import A2ACardResolver, ClientConfig, ClientFactory
+from a2a.client.helpers import create_text_message_object
+from a2a.types import AgentCapabilities, TaskState
+from a2a.types import AgentCard as A2AAgentCard
+from a2a.utils.constants import AGENT_CARD_WELL_KNOWN_PATH
+from agent_framework._mcp import MCPStreamableHTTPTool
+from agent_framework._tools import FunctionTool
+from agenticlayer.config import McpTool, SubAgent
+from httpx_retries import Retry, RetryTransport
+
+logger = logging.getLogger(__name__)
+
+
+def _make_a2a_tool(
+    name: str,
+    description: str,
+    url: str,
+    timeout: httpx.Timeout,
+) -> FunctionTool:
+    """Create a FunctionTool that calls a remote A2A agent via the A2A protocol.
+
+    Args:
+        name: The name to expose to the LLM.
+        description: Description of what the sub-agent does.
+        url: The A2A RPC URL of the sub-agent.
+        timeout: HTTP timeout to use when calling the sub-agent.
+
+    Returns:
+        A FunctionTool whose invocation sends an A2A message to the remote agent.
+    """
+
+    async def call_agent(request: str) -> str:
+        """Call the remote A2A sub-agent with a text request."""
+        async with httpx.AsyncClient(timeout=timeout) as http_client:
+            minimal_card = A2AAgentCard(
+                name=name,
+                description=description,
+                url=url,
+                version="0.1.0",
+                capabilities=AgentCapabilities(),
+                skills=[],
+                default_input_modes=["text/plain"],
+                default_output_modes=["text/plain"],
+                supports_authenticated_extended_card=False,
+            )
+            factory = ClientFactory(ClientConfig(httpx_client=http_client))
+            client = factory.create(minimal_card)
+
+            message = create_text_message_object(content=request)
+            response_text = f"No response from agent {name}"
+            async for event in client.send_message(message):
+                # ClientEvent is tuple[Task, update] or a Message; use isinstance to distinguish
+                if not isinstance(event, tuple):
+                    continue
+                task: Any = event[0]
+                if task.status.state == TaskState.completed and task.status.message:
+                    texts = [p.root.text for p in task.status.message.parts if hasattr(p.root, "text")]
+                    if texts:
+                        response_text = "\n".join(texts)
+                        break
+        return response_text
+
+    return FunctionTool(
+        name=name,
+        description=description or f"Call the {name} agent",
+        func=call_agent,
+    )
+
+
+class MsafAgentFactory:
+    """Factory for loading sub-agents and MCP tools into a Microsoft Agent Framework agent.
+
+    Fetches A2A agent cards at startup (failing fast if unreachable) and wraps each
+    sub-agent as a :class:`~agent_framework._tools.FunctionTool`.  MCP servers are
+    wrapped as :class:`~agent_framework._mcp.MCPStreamableHTTPTool` instances which
+    must be entered as async context managers before use.
+    """
+
+    def __init__(
+        self,
+        timeout: httpx.Timeout = httpx.Timeout(timeout=10),
+        retry: Retry = Retry(total=10, backoff_factor=0.5, max_backoff_wait=15),
+    ) -> None:
+        self.timeout = timeout
+        self.transport = RetryTransport(retry=retry)
+
+    async def load_sub_agents(self, sub_agents: list[SubAgent]) -> list[FunctionTool]:
+        """Fetch agent cards and create FunctionTools for sub-agents.
+
+        Raises :class:`~a2a.client.errors.A2AClientHTTPError` if any agent card
+        is unreachable (after retries), causing app startup to fail early.
+
+        Args:
+            sub_agents: List of sub-agent configurations.
+
+        Returns:
+            A list of FunctionTool instances, one per sub-agent.
+        """
+        tools: list[FunctionTool] = []
+        for sub_agent in sub_agents:
+            base_url = str(sub_agent.url).replace(AGENT_CARD_WELL_KNOWN_PATH, "")
+            async with httpx.AsyncClient(transport=self.transport, timeout=self.timeout) as client:
+                resolver = A2ACardResolver(httpx_client=client, base_url=base_url)
+                agent_card = await resolver.get_agent_card()
+            tool = _make_a2a_tool(
+                name=sub_agent.name,
+                description=agent_card.description,
+                url=agent_card.url,
+                timeout=self.timeout,
+            )
+            logger.info("Loaded sub-agent %s from %s", sub_agent.name, agent_card.url)
+            tools.append(tool)
+        return tools
+
+    def create_mcp_tools(self, mcp_tools: list[McpTool]) -> list[MCPStreamableHTTPTool]:
+        """Create MCPStreamableHTTPTool instances (not yet connected).
+
+        The returned tools must be entered as async context managers (i.e. ``async with tool``)
+        before they can be used with an agent.
+
+        Args:
+            mcp_tools: List of MCP tool configurations.
+
+        Returns:
+            A list of unconnected MCPStreamableHTTPTool instances.
+        """
+        tools: list[MCPStreamableHTTPTool] = []
+        for mcp_tool in mcp_tools:
+            logger.info("Creating MCP tool %s at %s", mcp_tool.name, mcp_tool.url)
+            tools.append(
+                MCPStreamableHTTPTool(
+                    name=mcp_tool.name,
+                    url=str(mcp_tool.url),
+                    request_timeout=mcp_tool.timeout,
+                )
+            )
+        return tools