acp-sdk 0.7.1__py3-none-any.whl → 0.7.3__py3-none-any.whl

acp_sdk/client/client.py

@@ -25,7 +25,6 @@ from acp_sdk.models import (
     Event,
     Run,
     RunCancelResponse,
-    RunCreatedEvent,
     RunCreateRequest,
     RunCreateResponse,
     RunId,
@@ -120,6 +119,11 @@ class Client:
         response = AgentReadResponse.model_validate(response.json())
         return Agent(**response.model_dump())
 
+    async def ping(self) -> bool:
+        response = await self._client.get("/healthcheck")
+        self._raise_error(response)
+        return response.json() == "OK"
+
     async def run_sync(self, input: Input, *, agent: AgentName) -> Run:
         response = await self._client.post(
             "/runs",
@@ -132,7 +136,6 @@ class Client:
         )
         self._raise_error(response)
         response = RunCreateResponse.model_validate(response.json())
-        self._set_session(response)
         return Run(**response.model_dump())
 
     async def run_async(self, input: Input, *, agent: AgentName) -> Run:
@@ -147,7 +150,6 @@ class Client:
         )
         self._raise_error(response)
         response = RunCreateResponse.model_validate(response.json())
-        self._set_session(response)
         return Run(**response.model_dump())
 
     async def run_stream(self, input: Input, *, agent: AgentName) -> AsyncIterator[Event]:
@@ -163,8 +165,6 @@ class Client:
             ).model_dump_json(),
         ) as event_source:
             async for event in self._validate_stream(event_source):
-                if isinstance(event, RunCreatedEvent):
-                    self._set_session(event.run)
                 yield event
 
     async def run_status(self, *, run_id: RunId) -> Run:
@@ -222,6 +222,3 @@ class Client:
             response.raise_for_status()
         except httpx.HTTPError:
             raise ACPError(Error.model_validate(response.json()))
-
-    def _set_session(self, run: Run) -> None:
-        self._session_id = run.session_id

acp_sdk/models/models.py

@@ -47,6 +47,11 @@ class Dependency(BaseModel):
     name: str
 
 
+class Capability(BaseModel):
+    name: str
+    description: str
+
+
 class Metadata(BaseModel):
     annotations: AnyModel | None = None
     documentation: str | None = None
@@ -54,7 +59,8 @@ class Metadata(BaseModel):
     programming_language: str | None = None
     natural_languages: list[str] | None = None
     framework: str | None = None
-    use_cases: list[str] | None = None
+    capabilities: list[Capability] | None = None
+    domains: list[str] | None = None
     tags: list[str] | None = None
     created_at: datetime | None = None
     updated_at: datetime | None = None
@@ -93,7 +99,7 @@ class Message(BaseModel):
     def __add__(self, other: "Message") -> "Message":
         if not isinstance(other, Message):
             raise TypeError(f"Cannot concatenate Message with {type(other).__name__}")
-        return Message(*(self.parts + other.parts))
+        return Message(parts=self.parts + other.parts)
 
     def __str__(self) -> str:
         return "".join(

acp_sdk/server/app.py

@@ -5,7 +5,7 @@ from datetime import datetime, timedelta
 from enum import Enum
 
 from cachetools import TTLCache
-from fastapi import FastAPI, HTTPException, status
+from fastapi import Depends, FastAPI, HTTPException, status
 from fastapi.encoders import jsonable_encoder
 from fastapi.responses import JSONResponse, StreamingResponse
 from opentelemetry.instrumentation.fastapi import FastAPIInstrumentor
@@ -47,7 +47,12 @@ class Headers(str, Enum):
     RUN_ID = "Run-ID"
 
 
-def create_app(*agents: Agent, run_limit: int = 1000, run_ttl: timedelta = timedelta(hours=1)) -> FastAPI:
+def create_app(
+    *agents: Agent,
+    run_limit: int = 1000,
+    run_ttl: timedelta = timedelta(hours=1),
+    dependencies: list[Depends] | None = None,
+) -> FastAPI:
     executor: ThreadPoolExecutor
 
     @asynccontextmanager
@@ -57,7 +62,10 @@ def create_app(*agents: Agent, run_limit: int = 1000, run_ttl: timedelta = timed
             executor = exec
             yield
 
-    app = FastAPI(lifespan=lifespan)
+    app = FastAPI(
+        lifespan=lifespan,
+        dependencies=dependencies,
+    )
 
     FastAPIInstrumentor.instrument_app(app)
 
@@ -96,11 +104,15 @@ def create_app(*agents: Agent, run_limit: int = 1000, run_ttl: timedelta = timed
         agent = find_agent(name)
         return AgentModel(name=agent.name, description=agent.description, metadata=agent.metadata)
 
+    @app.get("/healthcheck")
+    async def healthcheck() -> str:
+        return "OK"
+
     @app.post("/runs")
     async def create_run(request: RunCreateRequest) -> RunCreateResponse:
         agent = find_agent(request.agent_name)
 
-        session = sessions.get(request.session_id, Session()) if request.session_id else Session()
+        session = sessions.get(request.session_id, Session(id=request.session_id)) if request.session_id else Session()
         nonlocal executor
         bundle = RunBundle(
             agent=agent,

acp_sdk/server/server.py

@@ -4,6 +4,7 @@ from collections.abc import Awaitable
 from datetime import timedelta
 from typing import Any, Callable
 
+import requests
 import uvicorn
 import uvicorn.config
 
@@ -12,7 +13,9 @@ from acp_sdk.server.agent import Agent
 from acp_sdk.server.agent import agent as agent_decorator
 from acp_sdk.server.app import create_app
 from acp_sdk.server.logging import configure_logger as configure_logger_func
+from acp_sdk.server.logging import logger
 from acp_sdk.server.telemetry import configure_telemetry as configure_telemetry_func
+from acp_sdk.server.utils import async_request_with_retry
 
 
 class Server:
@@ -43,6 +46,7 @@ class Server:
         self,
         configure_logger: bool = True,
         configure_telemetry: bool = False,
+        self_registration: bool = True,
         run_limit: int = 1000,
         run_ttl: timedelta = timedelta(hours=1),
         host: str = "127.0.0.1",
@@ -158,7 +162,14 @@ class Server:
             h11_max_incomplete_event_size,
         )
         self._server = uvicorn.Server(config)
-        self._server.run()
+
+        asyncio.run(self._serve(self_registration=self_registration))
+
+    async def _serve(self, self_registration: bool = True) -> None:
+        registration_task = asyncio.create_task(self._register_agent()) if self_registration else None
+        await self._server.serve()
+        if registration_task:
+            registration_task.cancel()
 
     @property
     def should_exit(self) -> bool:
@@ -167,3 +178,45 @@ class Server:
     @should_exit.setter
     def should_exit(self, value: bool) -> None:
         self._server.should_exit = value
+
+    async def _register_agent(self) -> None:
+        """If not in PRODUCTION mode, register agent to the beeai platform and provide missing env variables"""
+        if os.getenv("PRODUCTION_MODE", False):
+            logger.debug("Agent is not automatically registered in the production mode.")
+            return
+
+        url = os.getenv("PLATFORM_URL", "http://127.0.0.1:8333")
+        for agent in self._agents:
+            request_data = {
+                "location": f"http://{self._server.config.host}:{self._server.config.port}",
+                "id": agent.name,
+            }
+            try:
+                await async_request_with_retry(
+                    lambda client, data=request_data: client.post(
+                        f"{url}/api/v1/provider/register/unmanaged", json=data
+                    )
+                )
+                logger.info("Agent registered to the beeai server.")
+
+                # check missing env keyes
+                envs_request = await async_request_with_retry(lambda client: client.get(f"{url}/api/v1/env"))
+                envs = envs_request.get("env")
+
+                # register all available envs
+                missing_keyes = []
+                for env in agent.metadata.model_dump().get("env", []):
+                    server_env = envs.get(env.get("name"))
+                    if server_env:
+                        logger.debug(f"Env variable {env['name']} = '{server_env}' added dynamically")
+                        os.environ[env["name"]] = server_env
+                    elif env.get("required"):
+                        missing_keyes.append(env)
+                if len(missing_keyes):
+                    logger.error(f"Can not run agent, missing required env variables: {missing_keyes}")
+                    raise Exception("Missing env variables")
+
+            except requests.exceptions.ConnectionError as e:
+                logger.warning(f"Can not reach server, check if running on {url} : {e}")
+            except (requests.exceptions.HTTPError, Exception) as e:
+                logger.warning(f"Agent can not be registered to beeai server: {e}")

acp_sdk/server/session.py

@@ -7,8 +7,8 @@ from acp_sdk.server.bundle import RunBundle
 
 
 class Session:
-    def __init__(self) -> None:
-        self.id: SessionId = uuid.uuid4()
+    def __init__(self, id: SessionId | None = None) -> None:
+        self.id: SessionId = id or uuid.uuid4()
         self.bundles: list[RunBundle] = []
 
     def append(self, bundle: RunBundle) -> None:

acp_sdk/server/utils.py

@@ -1,8 +1,13 @@
-from collections.abc import AsyncGenerator
+import asyncio
+from collections.abc import AsyncGenerator, Coroutine
+from typing import Any, Callable
 
+import httpx
+import requests
 from pydantic import BaseModel
 
 from acp_sdk.server.bundle import RunBundle
+from acp_sdk.server.logging import logger
 
 
 def encode_sse(model: BaseModel) -> str:
@@ -12,3 +17,33 @@ def encode_sse(model: BaseModel) -> str:
 async def stream_sse(bundle: RunBundle) -> AsyncGenerator[str]:
     async for event in bundle.stream():
         yield encode_sse(event)
+
+
+async def async_request_with_retry(
+    request_func: Callable[[httpx.AsyncClient], Coroutine[Any, Any, httpx.Response]],
+    max_retries: int = 5,
+    backoff_factor: float = 1,
+) -> dict[str, Any]:
+    async with httpx.AsyncClient() as client:
+        retries = 0
+        while retries < max_retries:
+            try:
+                response = await request_func(client)
+                response.raise_for_status()
+                return response.json()
+            except httpx.HTTPStatusError as e:
+                if e.response.status_code in [429, 500, 502, 503, 504, 509]:
+                    retries += 1
+                    backoff = backoff_factor * (2 ** (retries - 1))
+                    logger.warning(f"Request retry (try {retries}/{max_retries}), waiting {backoff} seconds...")
+                    await asyncio.sleep(backoff)
+                else:
+                    logger.debug("A non-retryable error was encountered.")
+                    raise
+            except httpx.RequestError:
+                retries += 1
+                backoff = backoff_factor * (2 ** (retries - 1))
+                logger.warning(f"Request retry (try {retries}/{max_retries}), waiting {backoff} seconds...")
+                await asyncio.sleep(backoff)
+
+        raise requests.exceptions.ConnectionError(f"Request failed after {max_retries} retries.")

{acp_sdk-0.7.1.dist-info → acp_sdk-0.7.3.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: acp-sdk
-Version: 0.7.1
+Version: 0.7.3
 Summary: Agent Communication Protocol SDK
 Author: IBM Corp.
 Maintainer-email: Tomas Pilar <thomas7pilar@gmail.com>

{acp_sdk-0.7.1.dist-info → acp_sdk-0.7.3.dist-info}/RECORD

@@ -3,25 +3,25 @@ acp_sdk/instrumentation.py,sha256=JqSyvILN3sGAfOZrmckQq4-M_4_5alyPn95DK0o5lfA,16
 acp_sdk/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 acp_sdk/version.py,sha256=Niy83rgvigB4hL_rR-O4ySvI7dj6xnqkyOe_JTymi9s,73
 acp_sdk/client/__init__.py,sha256=Bca1DORrswxzZsrR2aUFpATuNG2xNSmYvF1Z2WJaVbc,51
-acp_sdk/client/client.py,sha256=uIHlnB5TR9qe2yqWgQoSQBmdXZhMmsmmygxuhtnL6ew,8336
+acp_sdk/client/client.py,sha256=O5i7FW5L_u3OCtJD2_muqSMwVhymlTtxNdk2elVkcO8,8218
 acp_sdk/client/types.py,sha256=_H6zYt-2OHOOYRtssRnbDIiwmgsl2-KIXc9lb-mJLFA,133
 acp_sdk/client/utils.py,sha256=2jhJyrPJmVFRoDJh0q_JMqOMlC3IxCh-6HXed-PIZS8,924
 acp_sdk/models/__init__.py,sha256=numSDBDT1QHx7n_Y3Deb5VOvKWcUBxbOEaMwQBSRHxc,151
 acp_sdk/models/errors.py,sha256=rEyaMVvQuBi7fwWe_d0PGGySYsD3FZTluQ-SkC0yhAs,444
-acp_sdk/models/models.py,sha256=rQpc5eFSyDK_ALBXSjg6dTRNA6B0UFY3ssECY_1oIDc,6538
+acp_sdk/models/models.py,sha256=aA_ylU-Z0ZAlqPB8j-JfqJ2q516pgvTIyZ0wbfY8-UU,6654
 acp_sdk/models/schemas.py,sha256=OQ2bEfwFFZ1D9mhpgzfPBCcnPNvbl4qRfCWChH2wCro,644
 acp_sdk/server/__init__.py,sha256=mxBBBFaZuMEUENRMLwp1XZkuLeT9QghcFmNvjnqvAAU,377
 acp_sdk/server/agent.py,sha256=wvwpi83osmW7zQWxVnzyVMXIvzOswAfhKWHscVIldhA,6245
-acp_sdk/server/app.py,sha256=IocQBnXn1K6MP7aUvGSTD3TfVCKy9DGRZA3liYlfdYk,6599
+acp_sdk/server/app.py,sha256=QEkyM68oc9oxVl0ex5E4IMvyAToSiSIaBcUvwELWG4c,6827
 acp_sdk/server/bundle.py,sha256=P3DfmzQOewsK8jr8yG8_RsGSrXQI4PsZCQbspVxKlus,6552
 acp_sdk/server/context.py,sha256=MgnLV6qcDIhc_0BjW7r4Jj1tHts4ZuwpdTGIBnz2Mgo,1036
 acp_sdk/server/errors.py,sha256=GSO8yYIqEeX8Y4Lz86ks35dMTHiQiXuOrLYYx0eXsbI,2110
 acp_sdk/server/logging.py,sha256=Oc8yZigCsuDnHHPsarRzu0RX3NKaLEgpELM2yovGKDI,411
-acp_sdk/server/server.py,sha256=6mIVyURgJvcZCPad1CV8TcgHC2mqyEFCGgGATGyP34Q,5548
-acp_sdk/server/session.py,sha256=fCRPHc2sQrz4G0n25I1S4LB7mI1wo0yYQJ1V9WRWH3g,627
+acp_sdk/server/server.py,sha256=3b_nhbDR_VUz9lneJow4Jpw-6cF2xf2k94grYmfbm1E,8144
+acp_sdk/server/session.py,sha256=ekz1o6Sy1tQZlpaoS_VgbvFuUQh2qpiHG71mvBdvhgc,662
 acp_sdk/server/telemetry.py,sha256=1BUxNg-xL_Vqgs27PDWNc3HikrQW2lidAtT_FKlp_Qk,1833
 acp_sdk/server/types.py,sha256=teBNRWSks8XP1SCQKGEtbNWQahVD3RAOPnysTxcQPxI,292
-acp_sdk/server/utils.py,sha256=EfrF9VCyVk3AM_ao-BIB9EzGbfTrh4V2Bz-VFr6f6Sg,351
-acp_sdk-0.7.1.dist-info/METADATA,sha256=akqHFFa6cRGdqOTalPhM_lO9f9LGyaMRotTocAjRw9E,1651
-acp_sdk-0.7.1.dist-info/WHEEL,sha256=qtCwoSJWgHk21S1Kb4ihdzI2rlJ1ZKaIurTj_ngOhyQ,87
-acp_sdk-0.7.1.dist-info/RECORD,,
+acp_sdk/server/utils.py,sha256=y-DDWv_QI25OJJYP5cni2FzfolKXtH3S2SYOm6OL_gc,1835
+acp_sdk-0.7.3.dist-info/METADATA,sha256=v9-DPCCuw6NbWTuFyUDtI9UoTqxkkt1C4iS0wS1ATkw,1651
+acp_sdk-0.7.3.dist-info/WHEEL,sha256=qtCwoSJWgHk21S1Kb4ihdzI2rlJ1ZKaIurTj_ngOhyQ,87
+acp_sdk-0.7.3.dist-info/RECORD,,