agentkernel 0.1.0a2__tar.gz

agentkernel-0.1.0a2/PKG-INFO

@@ -0,0 +1,250 @@
+Metadata-Version: 2.3
+Name: agentkernel
+Version: 0.1.0a2
+Summary: Agent Kernel Python Distribution
+Author: Yaala Labs
+Author-email: Yaala Labs <info@yaalalabs.com>
+License: MIT
+Requires-Dist: pydantic>=2.11.7
+Requires-Dist: pydantic-settings>=2.10.1
+Requires-Dist: pyyaml>=6.0.2
+Requires-Dist: redis>=6.4.0
+Requires-Dist: a2a-sdk[http-server]>=0.3.6 ; extra == 'a2a'
+Requires-Dist: google-adk>=1.14.1 ; extra == 'adk'
+Requires-Dist: litellm~=1.74.3 ; extra == 'adk'
+Requires-Dist: fastapi>=0.118.0 ; extra == 'api'
+Requires-Dist: uvicorn>=0.37.0 ; extra == 'api'
+Requires-Dist: gunicorn>=23.0.0 ; extra == 'api'
+Requires-Dist: crewai>=0.150.0 ; extra == 'crewai'
+Requires-Dist: langgraph~=0.6.2 ; extra == 'langgraph'
+Requires-Dist: langchain~=0.3.27 ; extra == 'langgraph'
+Requires-Dist: langchain-community~=0.3.27 ; extra == 'langgraph'
+Requires-Dist: litellm~=1.74.3 ; extra == 'langgraph'
+Requires-Dist: fastmcp>=2.12.4 ; extra == 'mcp'
+Requires-Dist: openai-agents>=0.2.3 ; extra == 'openai'
+Requires-Dist: pytest>=8.4.1 ; extra == 'test'
+Requires-Dist: pytest-asyncio>=1.2.0 ; extra == 'test'
+Requires-Dist: pytest-cov>=6.2.1 ; extra == 'test'
+Requires-Dist: pytest-html>=4.1.1 ; extra == 'test'
+Requires-Dist: pytest-order>=1.3.0 ; extra == 'test'
+Requires-Dist: rapidfuzz>=3.14.1 ; extra == 'test'
+Requires-Python: >=3.12
+Provides-Extra: a2a
+Provides-Extra: adk
+Provides-Extra: api
+Provides-Extra: aws
+Provides-Extra: cli
+Provides-Extra: crewai
+Provides-Extra: langgraph
+Provides-Extra: mcp
+Provides-Extra: openai
+Provides-Extra: test
+Description-Content-Type: text/markdown
+
+# Agent Kernel (Python)
+
+Agent Kernel is a lightweight runtime and adapter layer that lets you build and run AI agents across multiple frameworks with a unified API. This package brings a common set of abstractions (Agent, Runner, Session, Module, Runtime) and integrations for:
+
+- OpenAI Agents SDK
+- CrewAI
+- LangGraph
+
+It also provides a simple interactive CLI and an AWS Lambda handler to deploy your agents as serverless endpoints.
+
+
+## Why Agent Kernel?
+
+- Unified model: Write agent logic once, run it under different frameworks via thin adapters.
+- Pluggable: Bring your own framework-specific agents and register them using a small shim.
+- Session-aware: Built-in session abstraction to maintain conversational or task state across runs.
+- Ready to use: CLI for local interaction, AWS Lambda handler for quick cloud deployment.
+
+
+## Installation
+
+This repository uses the uv toolchain. You can work from source easily.
+
+Prerequisites:
+- Python 3.12+
+- uv 0.8.0+
+
+From source (editable):
+
+```bash
+# Clone the repo and cd into ak-py
+uv sync  # install dependencies
+```
+
+Or using pip (if you package/publish it):
+
+```bash
+pip install ak-py
+```
+
+
+## Quick Start
+
+Below is the minimal mental model:
+
+- Agent: your framework-specific agent (e.g., a CrewAI Agent or a LangGraph CompiledStateGraph) wrapped by an Agent Kernel adapter.
+- Runner: framework-specific execution strategy.
+- Session: shared state across turns.
+- Module: a container that registers agents with the global Runtime on import/instantiation.
+- Runtime: a registry and orchestrator for agents.
+
+### Example: Define and register agents
+
+You typically create a Python module that constructs your framework agents and registers them with Agent Kernel by creating an agent module. Importing this module will register agents in the Runtime.
+
+CrewAI example (pseudo/minimal):
+
+```python
+# demo.py
+from crewai import Agent as CrewAgent
+from agentkernel.cli import CLI
+from agentkernel.crewai import CrewAIModule
+
+researcher = CrewAgent(role="researcher", goal="Find facts")
+writer = CrewAgent(role="writer", goal="Summarize findings")
+
+# Register both under Agent Kernel. The module maps each Crew agent to a CrewAIAgent
+# and registers them with the global Runtime.
+module = CrewAIModule([researcher, writer])
+if __name__ == "__main__":
+    CLI.main()
+```
+
+LangGraph example (pseudo/minimal):
+
+```python
+# demo.py
+from langgraph.graph import StateGraph
+from agentkernel.cli import CLI
+from agentkernel.langgraph import LangGraphModule
+
+# Build your graph and compile it to CompiledStateGraph with a `.name`
+sg = StateGraph(...)
+compiled = sg.compile()
+compiled.name = "assistant"  # ensure a name is set
+
+module = LangGraphModule([compiled])
+if __name__ == "__main__":
+    CLI.main()
+```
+
+OpenAI Agents SDK example (pseudo/minimal):
+
+```python
+# demo.py
+from openai import OpenAI
+from agents import Agent as OpenAIAgent  # from openai-agents SDK
+from agentkernel.cli import CLI
+from agentkernel.openai import OpenAIModule
+
+client = OpenAI()
+assistant = OpenAIAgent(name="assistant", client=client)  # add any required params for your SDK version
+
+module = OpenAIModule([assistant])
+if __name__ == "__main__":
+    CLI.main()
+```
+
+
+## Using the CLI
+
+Agent Kernel ships with a simple interactive CLI that lets you:
+- Load an agent module (which registers agents)
+- List/select an agent
+- Send prompts and view responses
+
+Run one of the above examples from the project:
+
+```bash
+uv run demo.py
+```
+
+Once inside, available commands:
+- !h, !help — Show help
+- !ld, !load <module_name> — Import a Python module that instantiates an agent module (e.g., my_crewai_agents)
+- !ls, !list — List registered agents
+- !s, !select <agent_name> — Select an agent by name
+- !n, !new — Start a new session
+- !q, !quit — Exit
+
+Tip: If your agent module registers at import time, you can simply run:
+
+```text
+(assistant) >> !load my_crewai_agents
+```
+
+
+## AWS Lambda Deployment
+
+A ready-to-use handler is provided at:
+
+- ak.aws:Lambda.handler
+
+OpenAI Agents SDK lambda example (pseudo/minimal):
+
+```python
+# demo.py
+from openai import OpenAI
+from agents import Agent as OpenAIAgent  # from openai-agents SDK
+from agentkernel.aws import Lambda
+from agentkernel.openai import OpenAIModule
+
+client = OpenAI()
+assistant = OpenAIAgent(name="assistant", client=client)  # add any required params for your SDK version
+
+module = OpenAIModule([assistant])
+handler = Lambda.handler
+```
+
+It expects an API Gateway-style event with a JSON body like:
+
+```json
+{
+  "prompt": "Hello agent",
+  "agent": "writer"  
+}
+```
+
+Response shape:
+- 200 with { "result": <string> }
+- 400 if no agent is available
+- 500 on unexpected errors
+
+Notes:
+- If no agent name is provided, the handler selects the first registered agent.
+- Make sure your deployment package (Lambda layer or container) includes your agent module and dependencies. Importing your agent module should register agents before the first request.
+
+## Development
+
+Requirements:
+- Python 3.12+
+- uv 0.8.0+
+
+Setup:
+
+```bash
+./build.sh  # installs dev dependencies and sets up environment
+```
+
+Run tests:
+
+```bash
+uv run pytest
+```
+
+Formatting and static checks (configured in pyproject.toml):
+- black
+- isort
+- mypy
+
+
+## Configuration and Extensibility
+
+- Configuration: See [CONFIG.md](CONFIG.md) for full details on environment variables and config file options.
+- Sessions: Use ak.ak.Session to keep per-conversation or per-job state across runs. Framework adapters manage their own session storage within that Session via namespaced keys (e.g., "crewai", "langgraph", "openai").
+- Adapters: See ak/crewai, ak/langgraph, ak/openai for reference implementations. To add a new framework, implement a Runner and an Agent wrapper, then a Module that registers them with Runtime.
+- Runtime: Agents are registered globally; Runtime.load(module_name) imports a module, which should instantiate an agent module to register its agents.

agentkernel-0.1.0a2/README.md

@@ -0,0 +1,207 @@
+# Agent Kernel (Python)
+
+Agent Kernel is a lightweight runtime and adapter layer that lets you build and run AI agents across multiple frameworks with a unified API. This package brings a common set of abstractions (Agent, Runner, Session, Module, Runtime) and integrations for:
+
+- OpenAI Agents SDK
+- CrewAI
+- LangGraph
+
+It also provides a simple interactive CLI and an AWS Lambda handler to deploy your agents as serverless endpoints.
+
+
+## Why Agent Kernel?
+
+- Unified model: Write agent logic once, run it under different frameworks via thin adapters.
+- Pluggable: Bring your own framework-specific agents and register them using a small shim.
+- Session-aware: Built-in session abstraction to maintain conversational or task state across runs.
+- Ready to use: CLI for local interaction, AWS Lambda handler for quick cloud deployment.
+
+
+## Installation
+
+This repository uses the uv toolchain. You can work from source easily.
+
+Prerequisites:
+- Python 3.12+
+- uv 0.8.0+
+
+From source (editable):
+
+```bash
+# Clone the repo and cd into ak-py
+uv sync  # install dependencies
+```
+
+Or using pip (if you package/publish it):
+
+```bash
+pip install ak-py
+```
+
+
+## Quick Start
+
+Below is the minimal mental model:
+
+- Agent: your framework-specific agent (e.g., a CrewAI Agent or a LangGraph CompiledStateGraph) wrapped by an Agent Kernel adapter.
+- Runner: framework-specific execution strategy.
+- Session: shared state across turns.
+- Module: a container that registers agents with the global Runtime on import/instantiation.
+- Runtime: a registry and orchestrator for agents.
+
+### Example: Define and register agents
+
+You typically create a Python module that constructs your framework agents and registers them with Agent Kernel by creating an agent module. Importing this module will register agents in the Runtime.
+
+CrewAI example (pseudo/minimal):
+
+```python
+# demo.py
+from crewai import Agent as CrewAgent
+from agentkernel.cli import CLI
+from agentkernel.crewai import CrewAIModule
+
+researcher = CrewAgent(role="researcher", goal="Find facts")
+writer = CrewAgent(role="writer", goal="Summarize findings")
+
+# Register both under Agent Kernel. The module maps each Crew agent to a CrewAIAgent
+# and registers them with the global Runtime.
+module = CrewAIModule([researcher, writer])
+if __name__ == "__main__":
+    CLI.main()
+```
+
+LangGraph example (pseudo/minimal):
+
+```python
+# demo.py
+from langgraph.graph import StateGraph
+from agentkernel.cli import CLI
+from agentkernel.langgraph import LangGraphModule
+
+# Build your graph and compile it to CompiledStateGraph with a `.name`
+sg = StateGraph(...)
+compiled = sg.compile()
+compiled.name = "assistant"  # ensure a name is set
+
+module = LangGraphModule([compiled])
+if __name__ == "__main__":
+    CLI.main()
+```
+
+OpenAI Agents SDK example (pseudo/minimal):
+
+```python
+# demo.py
+from openai import OpenAI
+from agents import Agent as OpenAIAgent  # from openai-agents SDK
+from agentkernel.cli import CLI
+from agentkernel.openai import OpenAIModule
+
+client = OpenAI()
+assistant = OpenAIAgent(name="assistant", client=client)  # add any required params for your SDK version
+
+module = OpenAIModule([assistant])
+if __name__ == "__main__":
+    CLI.main()
+```
+
+
+## Using the CLI
+
+Agent Kernel ships with a simple interactive CLI that lets you:
+- Load an agent module (which registers agents)
+- List/select an agent
+- Send prompts and view responses
+
+Run one of the above examples from the project:
+
+```bash
+uv run demo.py
+```
+
+Once inside, available commands:
+- !h, !help — Show help
+- !ld, !load <module_name> — Import a Python module that instantiates an agent module (e.g., my_crewai_agents)
+- !ls, !list — List registered agents
+- !s, !select <agent_name> — Select an agent by name
+- !n, !new — Start a new session
+- !q, !quit — Exit
+
+Tip: If your agent module registers at import time, you can simply run:
+
+```text
+(assistant) >> !load my_crewai_agents
+```
+
+
+## AWS Lambda Deployment
+
+A ready-to-use handler is provided at:
+
+- ak.aws:Lambda.handler
+
+OpenAI Agents SDK lambda example (pseudo/minimal):
+
+```python
+# demo.py
+from openai import OpenAI
+from agents import Agent as OpenAIAgent  # from openai-agents SDK
+from agentkernel.aws import Lambda
+from agentkernel.openai import OpenAIModule
+
+client = OpenAI()
+assistant = OpenAIAgent(name="assistant", client=client)  # add any required params for your SDK version
+
+module = OpenAIModule([assistant])
+handler = Lambda.handler
+```
+
+It expects an API Gateway-style event with a JSON body like:
+
+```json
+{
+  "prompt": "Hello agent",
+  "agent": "writer"  
+}
+```
+
+Response shape:
+- 200 with { "result": <string> }
+- 400 if no agent is available
+- 500 on unexpected errors
+
+Notes:
+- If no agent name is provided, the handler selects the first registered agent.
+- Make sure your deployment package (Lambda layer or container) includes your agent module and dependencies. Importing your agent module should register agents before the first request.
+
+## Development
+
+Requirements:
+- Python 3.12+
+- uv 0.8.0+
+
+Setup:
+
+```bash
+./build.sh  # installs dev dependencies and sets up environment
+```
+
+Run tests:
+
+```bash
+uv run pytest
+```
+
+Formatting and static checks (configured in pyproject.toml):
+- black
+- isort
+- mypy
+
+
+## Configuration and Extensibility
+
+- Configuration: See [CONFIG.md](CONFIG.md) for full details on environment variables and config file options.
+- Sessions: Use ak.ak.Session to keep per-conversation or per-job state across runs. Framework adapters manage their own session storage within that Session via namespaced keys (e.g., "crewai", "langgraph", "openai").
+- Adapters: See ak/crewai, ak/langgraph, ak/openai for reference implementations. To add a new framework, implement a Runner and an Agent wrapper, then a Module that registers them with Runtime.
+- Runtime: Agents are registered globally; Runtime.load(module_name) imports a module, which should instantiate an agent module to register its agents.

agentkernel-0.1.0a2/pyproject.toml

@@ -0,0 +1,95 @@
+[build-system]
+requires = ["uv_build>=0.8.2,<0.9.0"]
+build-backend = "uv_build"
+
+[project]
+name = "agentkernel"
+version = "0.1.0a2"
+description = "Agent Kernel Python Distribution"
+readme = "README.md"
+requires-python = ">=3.12"
+license = { text = "MIT" }
+authors = [
+    { name = "Yaala Labs", email = "info@yaalalabs.com" }
+]
+dependencies = [
+    "pydantic>=2.11.7",
+    "pydantic-settings>=2.10.1",
+    "pyyaml>=6.0.2",
+    "redis>=6.4.0",
+]
+
+[project.optional-dependencies]
+crewai = [
+    "crewai>=0.150.0"
+]
+langgraph = [
+    "langgraph~=0.6.2",
+    "langchain~=0.3.27",
+    "langchain_community~=0.3.27",
+    "litellm~=1.74.3"
+]
+cli = [
+
+]
+aws = [
+
+]
+openai = [
+    "openai-agents>=0.2.3"
+]
+adk = [
+    "google-adk>=1.14.1",
+    "litellm~=1.74.3"
+]
+api = [
+    "fastapi>=0.118.0",
+    "uvicorn>=0.37.0",
+    "gunicorn>=23.0.0"
+]
+test = [
+    "pytest>=8.4.1",
+    "pytest-asyncio>=1.2.0",
+    "pytest-cov>=6.2.1",
+    "pytest-html>=4.1.1",
+    "pytest-order>=1.3.0",
+    "rapidfuzz>=3.14.1",
+]
+a2a = [
+    "a2a-sdk[http-server]>=0.3.6",
+]
+mcp = [
+    "fastmcp>=2.12.4",
+]
+
+[dependency-groups]
+dev = [
+    "black>=23.0.0",
+    "isort>=5.0.0",
+    "mypy>=1.0.0",
+]
+
+
+[tool.uv]
+package = true
+
+[tool.isort]
+profile = "black"
+line_length = 88
+
+[tool.mypy]
+python_version = "3.12"
+
+# Common tool configurations that apply to all packages
+[tool.black]
+line-length = 88
+target-version = ["py312"]
+
+warn_return_any = true
+warn_unused_configs = true
+disallow_untyped_defs = true
+disallow_incomplete_defs = true
+
+[tool.pytest.ini_options]
+addopts = "--cov=src --cov-report=term --cov-report=html --html=report.html"
+

agentkernel-0.1.0a2/src/agentkernel/__init__.py

@@ -0,0 +1,21 @@
+"""
+Agent Kernel Python Distribution.
+
+This package provides a unified framework for working with different agent implementations and SDKs.
+It includes core functionality for agent execution, modular integration, and runtime management.
+
+Features:
+- Support for multiple agent frameworks (OpenAI, CrewAI, LangGraph)
+- Modular architecture for easy extension
+- Unified runtime environment
+- CLI interface for agent interaction
+"""
+
+import importlib.metadata
+
+try:
+    __version__ = importlib.metadata.version("agentkernel")
+except importlib.metadata.PackageNotFoundError:
+    __version__ = "0.1.0"
+
+from .core import *

agentkernel-0.1.0a2/src/agentkernel/a2a/a2a.py

@@ -0,0 +1,108 @@
+import logging
+import traceback
+from typing import Any
+
+from a2a.server.agent_execution import AgentExecutor, RequestContext
+from a2a.server.events import EventQueue
+from a2a.server.tasks import InMemoryTaskStore, TaskStore
+from a2a.types import UnsupportedOperationError, AgentCard, InternalError
+from a2a.utils import new_agent_text_message
+from a2a.utils.errors import ServerError
+
+from ..core import Agent, AgentService, Runtime
+from ..core.config import AKConfig
+
+
+class A2A:
+    """
+    A2A class provides a utility method for interacting with runtime, agents and sessions.
+    """
+    _cards: dict[str, AgentCard] = {}
+    """
+    A2A cards
+    """
+    _executors: dict[str, 'A2A.Executor'] = {}
+    """
+    A2A executors. A2A expects an executor per each agent
+    """
+    _built = False
+    """
+    Card built flag
+    """
+    _log = logging.getLogger(__name__)
+
+    class Executor(AgentExecutor):
+
+        def __init__(self, agent_name: str):
+            self.agent_name = agent_name
+            self.log = logging.getLogger(f"ak.a2a.executor.{agent_name}")
+
+        async def execute(self, context: RequestContext, event_queue: EventQueue) -> None:
+            if not context.task_id or not context.context_id:
+                raise ValueError("RequestContext must have task_id and context_id")
+            if not context.message:
+                raise ValueError("RequestContext must have a message")
+            try:
+                response = await self._execute_agent(context.context_id, context.get_user_input())
+                await event_queue.enqueue_event(
+                    new_agent_text_message(str(response), context.context_id, context.task_id))
+            except Exception as e:
+                error = "Sorry, Agent Kernel encountered an error while processing your request"
+                self.log.error(traceback.format_exc())
+                self.log.error(f'Exception: {e}')
+                await event_queue.enqueue_event(new_agent_text_message(error, context.context_id, context.task_id))
+                raise ServerError(error=InternalError()) from e
+
+        async def cancel(self, context: RequestContext, event_queue: EventQueue) -> None:
+            raise ServerError(error=UnsupportedOperationError())
+
+        async def _execute_agent(self, session_id: str, prompt: str) -> Any:
+            service = AgentService()
+            service.select(session_id, self.agent_name)
+            return await service.run(prompt=prompt)
+
+    @classmethod
+    def _build(cls):
+        if cls._built:
+            return
+        if not AKConfig.get().a2a.enabled:
+            return
+        agents: dict[str, Agent] = Runtime.instance().agents()
+        for name, agent in agents.items():
+            whitelisted = AKConfig.get().a2a.agents == ["*"] or name in AKConfig.get().a2a.agents
+            if not whitelisted:
+                continue
+            # get card
+            card: AgentCard = agent.get_a2a_card()
+            cls._cards.update({name: card})
+        cls._built = True
+
+    @classmethod
+    def get_executor(cls, agent_name: str) -> AgentExecutor:
+        if cls._executors.get(agent_name) is None:
+            cls._executors[agent_name] = cls.Executor(agent_name)
+        executor: A2A.Executor = cls._executors[agent_name]
+        return executor
+
+    @classmethod
+    def get_cards(cls) -> list[AgentCard]:
+        cls._build()
+        return list(cls._cards.values())
+
+    @classmethod
+    def get_card(cls, name: str) -> AgentCard:
+        cls._build()
+        return cls._cards.get(name)
+
+    @classmethod
+    def get_agent_names(cls) -> list[str]:
+        cls._build()
+        return list(cls._cards.keys())
+
+    @classmethod
+    def get_task_store(cls) -> TaskStore:
+        return RedisTaskStore() if AKConfig.get().a2a.task_store_type == "redis" else InMemoryTaskStore()
+
+
+class RedisTaskStore(InMemoryTaskStore):
+    pass

agentkernel-0.1.0a2/src/agentkernel/adk/__init__.py

@@ -0,0 +1,16 @@
+"""
+Agent Kernel support for GoogleADK Agents.
+
+This package contains Agent Kernel support for agents built with GoogleADK Agents.
+It provides the necessary classes and methods to integrate GoogleADK agents into the Agent Kernel
+framework, allowing for seamless interaction and execution of GoogleADK based agents.
+"""
+
+import importlib.metadata
+
+try:
+    __version__ = importlib.metadata.version("agentkernel")
+except importlib.metadata.PackageNotFoundError:
+    __version__ = "0.1.0"
+
+from .adk import GoogleADKModule