slima2a 0.1.0__tar.gz

slima2a-0.1.0/.gitignore

@@ -0,0 +1,124 @@
+# Byte-compiled / optimized / DLL files
+__pycache__/
+*.py[cod]
+*$py.class
+
+# C extensions
+*.so
+
+# Virtual Environments
+.venv
+
+# Distribution / packaging
+.Python
+build/
+develop-eggs/
+dist/
+downloads/
+eggs/
+.eggs/
+lib/
+lib64/
+parts/
+sdist/
+var/
+*.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
+.pytest_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
+target
+
+# Jupyter Notebook
+.ipynb_checkpoints
+
+# IPython
+profile_default/
+ipython_config.py
+
+# pyenv
+.python-version
+
+# mypy
+.mypy_cache/
+.dmypy.json
+dmypy.json
+
+# Pyre type checker
+.pyre/
+
+# VS Code
+.vscode/
+
+# MacOS
+.DS_Store
+
+# Ruff
+.ruff_cache
+
+# env file
+.env
+
+# tools
+.tools
+.tmp
+
+# binaris
+.dist
+
+# coverage
+*-coverage.out
+coverage.out
+
+# pyd files
+.pyd
+
+# this schema is copied over from dataplane
+control-plane/common/controller/schema.json

slima2a-0.1.0/CHANGELOG.md

@@ -0,0 +1,16 @@
+# Changelog
+
+## 0.1.0 (2025-09-18)
+
+
+### Features
+
+* rename srpc python import to slimrpc ([#660](https://github.com/agntcy/slim/issues/660)) ([d7ed9b2](https://github.com/agntcy/slim/commit/d7ed9b206c49096628541404766790c6a2406d7e))
+* **slimrpc:** separate Channel and ChannelFactory ([#685](https://github.com/agntcy/slim/issues/685)) ([3dc8a5b](https://github.com/agntcy/slim/commit/3dc8a5b8a434180a275fcbce5f26b62b3739b4c9))
+* **slimrpc:** Support existing slim binding in ChannelFactory ([#690](https://github.com/agntcy/slim/issues/690)) ([d7093b7](https://github.com/agntcy/slim/commit/d7093b7b022e5fc707ecef61953e6016f05e4a73))
+* update version of slima2a and slimrpc wheels ([#637](https://github.com/agntcy/slim/issues/637)) ([e6569cb](https://github.com/agntcy/slim/commit/e6569cba88afff65b7a736f7511d9ea2a57f7dc2))
+
+
+### Bug Fixes
+
+* **slima2a, slimrpc:** make mypy happy ([#671](https://github.com/agntcy/slim/issues/671)) ([5ab4628](https://github.com/agntcy/slim/commit/5ab462854c57a4788cc5eec8eecc734ab34cb2d5))

slima2a-0.1.0/PKG-INFO

@@ -0,0 +1,95 @@
+Metadata-Version: 2.4
+Name: slima2a
+Version: 0.1.0
+Summary: A2A protocol over slimrpc
+Project-URL: Repository, https://github.com/agntcy/slim
+Project-URL: Issues, https://github.com/agntcy/slim/issues
+Project-URL: Changelog, https://github.com/agntcy/slim/blob/main/data-plane/python/integrations/slima2a/CHANGELOG.md
+Classifier: Development Status :: 3 - Alpha
+Classifier: Intended Audience :: Developers
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Programming Language :: Python :: 3.13
+Classifier: Topic :: Software Development :: Libraries
+Requires-Python: <4.0,>=3.10
+Requires-Dist: a2a-sdk[telemetry]>=0.3.0
+Requires-Dist: slimrpc==0.1.0
+Description-Content-Type: text/markdown
+
+# SLIMA2A
+
+SLIMA2A is a native integration of A2A built on top of SLIM.
+
+## Server usage
+
+```python
+import srpc
+from a2a.server.request_handlers import DefaultRequestHandler
+from slima2a.handler import SRPCHandler
+from slima2a.types.a2a_pb2_srpc import add_A2AServiceServicer_to_server
+
+agent_executor = MyAgentExecutor()
+request_handler = DefaultRequestHandler(
+     agent_executor=agent_executor, task_store=InMemoryTaskStore()
+)
+
+servicer = SRPCHandler(agent_card, request_handler)
+
+server = srpc.Server(
+    local="agntcy/demo/server",
+    slim={
+        "endpoint": "http://localhost:46357",
+        "tls": {
+            "insecure": True,
+            },
+        },
+        shared_secret="secret",
+    )
+
+a2a_pb2_srpc.add_A2AServiceServicer_to_server(
+        servicer
+        server,
+    )
+
+await server.start()
+```
+
+## Client Usage
+
+```python
+from srpc import SRPCChannel
+from a2a.client import ClientFactory, minimal_agent_card
+from slima2a.client_transport import SRPCTransport, ClientConfig
+
+def channel_factory(topic) -> SRPCChannel:
+    channel = srpc.Channel(
+        local="agntcy/demo/client",
+        remote="agntcy/demo/server",
+        slim={
+            "endpoint": "http://localhost:46357",
+            "tls": {
+                "insecure": True,
+                },
+            },
+        shared_secret="secret",
+    )
+    return channel
+
+client_config = ClientConfig(
+    supported_transports=["JSONRPC", "srpc"],
+    streaming=args.stream,
+    httpx_client=httpx_client,
+    srpc_channel_factory=channel_factory,
+)
+client_factory = ClientFactory(client_config)
+client_factory.register("srpc", SRPCTransport.create)
+
+ac = minimal_agent_card("agntcy/demo/server", ["srpc"])
+client = factory.create(ac)
+
+try:
+    response = client.send_message(...)
+except srpc.SRPCResponseError as e:
+    ...
+```

slima2a-0.1.0/README.md

@@ -0,0 +1,190 @@
+# SLIMA2A
+
+SLIMA2A is a native integration of A2A built on top of SLIM. It utilizes SLIM
+RPC and the SLIM RPC compiler to compile A2A protobuf file and generate the
+necessary code to enable A2A functionality on SLIM.
+
+# What is SLIM RPC and SLIM RCP compiler
+
+SLIM RPC (SLIM Remote Procedure Call) is a framework that enables Protocol
+Buffers (protobuf) Remote Procedure Calls (RPC) over SLIM. This is similar to
+gRPC, which uses HTTP/2 as its transport layer for protobuf-based RPC. More
+information can be found [here](../slimrpc/README.md)
+
+To compile a protobuf file and generate the clients and service stub you can use
+the [SLIM RPC compiler](../../../srpc-compiler/README.md). This works in a
+similar way to the protoc compiler.
+
+For SLIM A2A we compiled the
+[a2a.proto](https://github.com/a2aproject/A2A/blob/main/specification/grpc/a2a.proto)
+file using the SLIM RPC compiler. The generated code is in
+[a2a_pb2_srpc.py](./slima2a/types/a2a_pb2_srpc.py).
+
+# How to use SLIM A2A
+
+Using SLIM A2A is very similar to using the standard A2A implementation. As a
+reference example here we use the [travel planner
+agent](https://github.com/a2aproject/a2a-samples/tree/main/samples/python/agents/travel_planner_agent)
+available on the A2A samples repo. The version adapted to use SLIM A2A can be
+found in [travel_planner_agent](./examples/travel_planner_agent/) folder. In the
+following section, we highlight and explain the key differences between the
+standard and SLIM A2A implementations.
+
+## Travel Planner: Server
+
+In this section we highlight the main differences between the SLIM A2A
+[server](./examples/travel_planner_agent/server.py) implementation with respect
+to the original implementation in the A2A repository.
+
+1. Import the SRPC package
+
+```python
+import srpc
+```
+
+2. Create the SRPCHandler. Notice that the definitions for `AgentCard` and
+   `DefaultRequestHandler` remain unchanged from the original A2A example
+
+```python
+    agent_card = AgentCard(
+        name="travel planner Agent",
+        description="travel planner",
+        url="http://localhost:10001/",
+        version="1.0.0",
+        default_input_modes=["text"],
+        default_output_modes=["text"],
+        capabilities=AgentCapabilities(streaming=True),
+        skills=[skill],
+    )
+
+    request_handler = DefaultRequestHandler(
+        agent_executor=TravelPlannerAgentExecutor(),
+        task_store=InMemoryTaskStore(),
+    )
+
+    servicer = SRPCHandler(agent_card, request_handler)
+```
+
+3. Setup the srcp.Server. This is the only place where you need to setup few
+   parameters that are specific to SLIM
+
+```python
+    server = srpc.Server(
+        local="agntcy/demo/travel_planner_agent",
+        slim={
+            "endpoint": "http://localhost:46357",
+            "tls": {
+                "insecure": True,
+            },
+        },
+        shared_secret="secret",
+    )
+```
+
+    •	local: Name of the local application.
+    •	slim: Dictionary specifying how to connect to the SLIM node.
+    •	shared_secret: Used to set up MLS (Message Layer Security).
+
+For more information about these settings, see the SLIM RCP
+[README](../slimrpc/README.md).
+
+4. Register the Service
+
+```python
+    add_A2AServiceServicer_to_server(
+        servicer,
+        server,
+    )
+```
+
+Your A2A server is now ready to run on SLIM.
+
+## Travel Planner: Client
+
+These are the main differences between the
+[client](./examples/travel_planner_agent/client.py) using SLIM A2A and the
+standard one.
+
+1. Create a channel. This requires a configuration that is similar to the server
+
+```python
+    def channel_factory(topic: str) -> srpc.Channel:
+        channel = srpc.Channel(
+            local="agntcy/demo/client",
+            remote=topic,
+            slim={
+                "endpoint": "http://localhost:46357",
+                "tls": {
+                    "insecure": True,
+                },
+            },
+            shared_secret="secret",
+        )
+        return channel
+```
+
+2. Add SLIM RPC in the supported transports.
+
+```python
+    client_config = ClientConfig(
+        supported_transports=["JSONRPC", "srpc"],
+        streaming=True,
+        httpx_client=httpx_client,
+        srpc_channel_factory=channel_factory,
+    )
+    client_factory = ClientFactory(client_config)
+    client_factory.register("srpc", SRPCTransport.create)
+    agent_card = minimal_agent_card("agntcy/demo/travel_planner_agent", ["srpc"])
+    client = client_factory.create(card=agent_card)
+```
+
+<!--
+```
+from a2a.server.request_handlers import DefaultRequestHandler
+
+agent_executor = MyAgentExecutor()
+request_handler = DefaultRequestHandler(
+     agent_executor=agent_executor, task_store=InMemoryTaskStore()
+)
+
+servicer = SRPCHandler(agent_card, request_handler)
+
+server = slimrpc.server()
+a2a_pb2_slimrpc.add_A2AServiceServicer_to_server(
+        servicer
+        server,
+    )
+
+await server.start()
+```
+
+## Client Usage
+
+```
+from slimrpc import SRPCChannel
+from a2a.client import ClientFactory, minimal_agent_card
+from slima2a.client_transport import SRPCTransport, ClientConfig
+
+def channel_factory(topic) -> SRPCChannel:
+    channel = SRPCChannel(
+        local=local,
+        slim=slim,
+        enable_opentelemetry=enable_opentelemetry,
+        shared_secret=shared_secret,
+    )
+    await channel.connect(topic)
+    return channel
+
+clientConfig = ClientConfig(slimrpc_channel_factor=channel_factor)
+
+factory = ClientFactory(clientConfig)
+factory.register('slimrpc', SRPCTransport.create)
+ac = minimal_agent_card(topic, ["slimrpc"])
+client = factory.create(ac)
+
+try:
+    response = client.send_message(...)
+except slimrpc.SRPCResponseError as e:
+    ...
+```
+--->

slima2a-0.1.0/README_pypi.md

@@ -0,0 +1,76 @@
+# SLIMA2A
+
+SLIMA2A is a native integration of A2A built on top of SLIM.
+
+## Server usage
+
+```python
+import srpc
+from a2a.server.request_handlers import DefaultRequestHandler
+from slima2a.handler import SRPCHandler
+from slima2a.types.a2a_pb2_srpc import add_A2AServiceServicer_to_server
+
+agent_executor = MyAgentExecutor()
+request_handler = DefaultRequestHandler(
+     agent_executor=agent_executor, task_store=InMemoryTaskStore()
+)
+
+servicer = SRPCHandler(agent_card, request_handler)
+
+server = srpc.Server(
+    local="agntcy/demo/server",
+    slim={
+        "endpoint": "http://localhost:46357",
+        "tls": {
+            "insecure": True,
+            },
+        },
+        shared_secret="secret",
+    )
+
+a2a_pb2_srpc.add_A2AServiceServicer_to_server(
+        servicer
+        server,
+    )
+
+await server.start()
+```
+
+## Client Usage
+
+```python
+from srpc import SRPCChannel
+from a2a.client import ClientFactory, minimal_agent_card
+from slima2a.client_transport import SRPCTransport, ClientConfig
+
+def channel_factory(topic) -> SRPCChannel:
+    channel = srpc.Channel(
+        local="agntcy/demo/client",
+        remote="agntcy/demo/server",
+        slim={
+            "endpoint": "http://localhost:46357",
+            "tls": {
+                "insecure": True,
+                },
+            },
+        shared_secret="secret",
+    )
+    return channel
+
+client_config = ClientConfig(
+    supported_transports=["JSONRPC", "srpc"],
+    streaming=args.stream,
+    httpx_client=httpx_client,
+    srpc_channel_factory=channel_factory,
+)
+client_factory = ClientFactory(client_config)
+client_factory.register("srpc", SRPCTransport.create)
+
+ac = minimal_agent_card("agntcy/demo/server", ["srpc"])
+client = factory.create(ac)
+
+try:
+    response = client.send_message(...)
+except srpc.SRPCResponseError as e:
+    ...
+```

slima2a-0.1.0/Taskfile.yaml

@@ -0,0 +1,20 @@
+# Copyright AGNTCY Contributors (https://github.com/agntcy)
+# SPDX-License-Identifier: Apache-2.0
+
+---
+
+version: '3'
+
+includes:
+  python:
+    taskfile: ../../../../tasks/python.yaml
+    vars:
+      UV_ARGS: '--package slima2a'
+
+tasks:
+  generate_a2a_types:
+    desc: |
+      Generate the a2a protobuf lib
+    cmds:
+      - |
+        buf generate

slima2a-0.1.0/buf.gen.yaml

@@ -0,0 +1,24 @@
+---
+version: v2
+inputs:
+  - git_repo: https://github.com/a2aproject/A2A.git
+    ref: main
+    subdir: specification/grpc
+managed:
+  enabled: true
+plugins:
+  # Generate python protobuf related code
+  # Generates _pb2_slimrpc.py files
+
+  # TODO: this should be downloaded from a released plugin version
+  - local: ../../target/debug/protoc-slimrpc-plugin
+    out: slima2a/types
+    opt:
+      - 'types_import=from a2a.grpc import a2a_pb2 as a2a__pb2'
+
+  # Generates *_pb2.py files, one for each .proto
+  #- remote: buf.build/protocolbuffers/python:v29.3
+  #  out: slima2a/types
+  # Generates *_pb2.pyi files.
+  #- remote: buf.build/protocolbuffers/pyi:v31.1
+  #  out: slima2a/types

slima2a-0.1.0/pyproject.toml

@@ -0,0 +1,67 @@
+# Copyright AGNTCY Contributors (https://github.com/agntcy)
+# SPDX-License-Identifier: Apache-2.0
+
+[project]
+name = "slima2a"
+version = "0.1.0"
+description = "A2A protocol over slimrpc"
+readme = "README_pypi.md"
+requires-python = ">=3.10, <4.0"
+dependencies = ["a2a-sdk[telemetry]>=0.3.0", "slimrpc==0.1.0"]
+classifiers = [
+    "Development Status :: 3 - Alpha",
+
+    # Indicate who your project is intended for
+    "Intended Audience :: Developers",
+    "Topic :: Software Development :: Libraries",
+
+    # Specify the Python versions you support here.
+    "Programming Language :: Python :: 3.10",
+    "Programming Language :: Python :: 3.11",
+    "Programming Language :: Python :: 3.12",
+    "Programming Language :: Python :: 3.13",
+]
+
+[project.urls]
+Repository = "https://github.com/agntcy/slim"
+Issues = "https://github.com/agntcy/slim/issues"
+Changelog = "https://github.com/agntcy/slim/blob/main/data-plane/python/integrations/slima2a/CHANGELOG.md"
+
+[dependency-groups]
+linting = ["ruff>=0.12", "mypy>=1.17.0", "types-protobuf>=6.30.2.20250822"]
+testing = ["pytest>=8.3.4"]
+examples = [
+    "langchain-core",
+    "langchain-openai",
+    "typing-extensions",
+    "uvicorn>=0.34.2",
+]
+
+# Default groups to install when running `uv sync`
+[tool.uv]
+default-groups = ["linting", "testing", "examples"]
+
+[tool.uv.sources]
+slimrpc = { workspace = true }
+
+[tool.ruff.format]
+exclude = ["*_pb2.py", "*_pb2.pyi", "*_pb2_slimrpc.py"]
+
+[tool.ruff.lint]
+extend-select = ["I", "ASYNC", "SIM", "B", "ANN"]
+exclude = ["*_pb2.py", "*_pb2.pyi", "*_pb2_slimrpc.py"]
+
+[build-system]
+requires = ["hatchling"]
+build-backend = "hatchling.build"
+
+[tool.hatch.build.targets.wheel]
+packages = ["slima2a"]
+exclude = ["examples"]
+
+[tool.hatch.build.targets.sdist]
+exclude = ["examples"]
+
+[[tool.mypy.overrides]]
+module = ["google.rpc.*"]
+follow_untyped_imports = true