uagents-core 0.3.5__tar.gz → 0.3.7__tar.gz

{uagents_core-0.3.5 → uagents_core-0.3.7}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.3
 Name: uagents-core
-Version: 0.3.5
+Version: 0.3.7
 Summary: Core components for agent based systems
 License: Apache 2.0
 Author: Ed FitzGerald

{uagents_core-0.3.5 → uagents_core-0.3.7}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "uagents-core"
-version = "0.3.5"
+version = "0.3.7"
 description = "Core components for agent based systems"
 authors = [
     { name = "Ed FitzGerald", email = "edward.fitzgerald@fetch.ai" },

{uagents_core-0.3.5 → uagents_core-0.3.7}/uagents_core/contrib/protocols/chat/__init__.py

@@ -2,8 +2,9 @@
 This module contains the protocol specification for the agent chat protocol.
 """
 
-from datetime import datetime
+from datetime import datetime, timezone
 from typing import Literal, TypedDict
+from uuid import uuid4
 
 from pydantic.v1 import UUID4
 
@@ -27,6 +28,9 @@ class TextContent(Model):
     # markdown based formatting can be used and will be supported by most clients
     text: str
 
+    def __init__(self, text: str, type: str = "text"):
+        super().__init__(type=type, text=text)
+
 
 class Resource(Model):
     # the uri of the resource
@@ -36,6 +40,9 @@ class Resource(Model):
     # fields see `docs/metadata.md`
     metadata: dict[str, str]
 
+    def __init__(self, uri: str, metadata: dict[str, str] | None = None):
+        super().__init__(uri=uri, metadata=metadata or {})
+
 
 class ResourceContent(Model):
     type: Literal["resource"]
@@ -51,6 +58,14 @@ class ResourceContent(Model):
     # considered the primary resource
     resource: Resource | list[Resource]
 
+    def __init__(
+        self,
+        resource_id: UUID4,
+        resource: Resource | list[Resource],
+        type: str = "resource",
+    ):
+        super().__init__(type=type, resource_id=resource_id, resource=resource)
+
 
 class MetadataContent(Model):
     type: Literal["metadata"]
@@ -59,26 +74,41 @@ class MetadataContent(Model):
     # fields see `docs/metadata.md`
     metadata: dict[str, str]
 
+    def __init__(self, metadata: dict[str, str], type: str = "metadata"):
+        super().__init__(type=type, metadata=metadata)
+
 
 class StartSessionContent(Model):
     type: Literal["start-session"]
 
+    def __init__(self, type: str = "start-session"):
+        super().__init__(type=type)
+
 
 class EndSessionContent(Model):
     type: Literal["end-session"]
 
+    def __init__(self, type: str = "end-session"):
+        super().__init__(type=type)
+
 
 class StartStreamContent(Model):
     type: Literal["start-stream"]
 
     stream_id: UUID4
 
+    def __init__(self, stream_id: UUID4, type: str = "start-stream"):
+        super().__init__(type=type, stream_id=stream_id)
+
 
 class EndStreamContent(Model):
     type: Literal["end-stream"]
 
     stream_id: UUID4
 
+    def __init__(self, stream_id: UUID4, type: str = "end-stream"):
+        super().__init__(type=type, stream_id=stream_id)
+
 
 # The combined agent content types
 AgentContent = (
@@ -102,6 +132,16 @@ class ChatMessage(Model):
     # the list of content elements in the chat
     content: list[AgentContent]
 
+    def __init__(
+        self,
+        content: list[AgentContent],
+        msg_id: UUID4 | None = None,
+        timestamp: datetime | None = None,
+    ):
+        msg_id = msg_id or uuid4()
+        timestamp = timestamp or datetime.now(timezone.utc)
+        super().__init__(timestamp=timestamp, msg_id=msg_id, content=content)
+
 
 class ChatAcknowledgement(Model):
     # the timestamp for the message, should be in UTC
@@ -113,6 +153,19 @@ class ChatAcknowledgement(Model):
     # optional acknowledgement metadata
     metadata: dict[str, str] | None = None
 
+    def __init__(
+        self,
+        acknowledged_msg_id: UUID4,
+        metadata: dict[str, str] | None = None,
+        timestamp: datetime | None = None,
+    ):
+        timestamp = timestamp or datetime.now(timezone.utc)
+        super().__init__(
+            timestamp=timestamp,
+            acknowledged_msg_id=acknowledged_msg_id,
+            metadata=metadata,
+        )
+
 
 chat_protocol_spec = ProtocolSpecification(
     name="AgentChatProtocol",

{uagents_core-0.3.5 → uagents_core-0.3.7}/uagents_core/types.py

@@ -22,6 +22,8 @@ class AgentInfo(BaseModel):
     endpoints: list[AgentEndpoint]
     protocols: list[str]
     metadata: dict[str, Any] | None = None
+    agent_type: AgentType
+    port: int | None = None
 
 
 class DeliveryStatus(str, Enum):

{uagents_core-0.3.5 → uagents_core-0.3.7}/uagents_core/utils/messages.py

@@ -2,19 +2,24 @@
 This module provides methods to enable an identity to interact with other agents.
 """
 
+import contextlib
 import json
 from typing import Any, Literal
 from uuid import UUID, uuid4
 
 import requests
+from pydantic import ValidationError
 
-from uagents_core.config import DEFAULT_REQUEST_TIMEOUT, AgentverseConfig
+from uagents_core.config import (
+    DEFAULT_MAX_ENDPOINTS,
+    DEFAULT_REQUEST_TIMEOUT,
+    AgentverseConfig,
+)
 from uagents_core.envelope import Envelope
-from uagents_core.helpers import weighted_random_sample
 from uagents_core.identity import Identity
 from uagents_core.logger import get_logger
 from uagents_core.models import Model
-from uagents_core.types import DeliveryStatus, MsgStatus, Resolver
+from uagents_core.types import DeliveryStatus, JsonStr, MsgStatus, Resolver
 from uagents_core.utils.resolver import AlmanacResolver
 
 logger = get_logger("uagents_core.utils.messages")
@@ -58,7 +63,10 @@ def generate_message_envelope(
 
 
 def send_message(
-    endpoint: str, envelope: Envelope, timeout: int = DEFAULT_REQUEST_TIMEOUT
+    endpoint: str,
+    envelope: Envelope,
+    timeout: int = DEFAULT_REQUEST_TIMEOUT,
+    sync: bool = False,
 ) -> requests.Response:
     """
     A helper function to send a message to an agent.
@@ -67,13 +75,17 @@ def send_message(
         endpoint (str): The endpoint to send the message to.
         envelope (Envelope): The envelope containing the message.
         timeout (int, optional): Requests timeout. Defaults to DEFAULT_REQUEST_TIMEOUT.
+        sync (bool, optional): Whether to send the message synchronously. Defaults to False.
 
     Returns:
         requests.Response: Response object from the request.
     """
+    headers = {"content-type": "application/json"}
+    if sync:
+        headers["x-uagents-connection"] = "sync"
     response = requests.post(
         url=endpoint,
-        headers={"content-type": "application/json"},
+        headers=headers,
         data=envelope.model_dump_json(),
         timeout=timeout,
     )
@@ -81,6 +93,39 @@ def send_message(
     return response
 
 
+def parse_sync_response(
+    env_json: JsonStr,
+    response_type: type[Model] | set[type[Model]] | None = None,
+) -> Model | JsonStr:
+    """
+    Parse the response from a synchronous message.
+
+    Args:
+        env_json (JsonStr): The JSON string of the response envelope.
+        response_type (type[Model] | set[type[Model]] | None, optional):
+            The expected response type(s) for a sync message.
+
+    Returns:
+        Model | JsonStr: The parsed response model or JSON string.
+    """
+
+    env = Envelope.model_validate_json(env_json)
+
+    response_json = env.decode_payload()
+
+    response_msg: Model | None = None
+    if response_type:
+        response_types = (
+            {response_type} if isinstance(response_type, type) else response_type
+        )
+
+        for r_type in response_types:
+            with contextlib.suppress(ValidationError):
+                response_msg = r_type.parse_raw(response_json)
+
+    return response_msg or response_json
+
+
 def send_message_to_agent(
     destination: str,
     msg: Model,
@@ -90,7 +135,9 @@ def send_message_to_agent(
     strategy: Literal["first", "random", "all"] = "first",
     agentverse_config: AgentverseConfig | None = None,
     resolver: Resolver | None = None,
-) -> list[MsgStatus]:
+    sync: bool = False,
+    response_type: type[Model] | set[type[Model]] | None = None,
+) -> list[MsgStatus] | Model | JsonStr:
     """
     Send a message to an agent with default settings.
 
@@ -102,11 +149,21 @@ def send_message_to_agent(
         strategy (Literal["first", "random", "all"], optional): The strategy to use when
             selecting an endpoint.
         agentverse_config (AgentverseConfig, optional): The configuration for the agentverse.
+        resolver (Resolver, optional): The resolver to use for finding endpoints.
+        sync (bool, optional): Whether to send the message synchronously and wait for a response.
+        response_type (type[Model] | set[type[Model]] | None, optional):
+            The expected response type(s) for a sync message.
+
+    Returns:
+        list[MsgStatus] | Model | JsonStr: A list of message statuses
+            or the response model or json string if sync is True.
     """
     agentverse_config = agentverse_config or AgentverseConfig()
 
     if not resolver:
+        max_endpoints = 1 if strategy in ["first", "random"] else DEFAULT_MAX_ENDPOINTS
         resolver = AlmanacResolver(
+            max_endpoints=max_endpoints,
             agentverse_config=agentverse_config,
         )
     endpoints = resolver.sync_resolve(destination)
@@ -121,31 +178,24 @@ def send_message_to_agent(
         sender=sender,
         session_id=session_id,
     )
-    match strategy:
-        case "first":
-            endpoints = endpoints[:1]
-        case "random":
-            endpoints = weighted_random_sample(endpoints)
-
-    endpoints: list[str] = endpoints if strategy == "all" else endpoints[:1]
 
-    result: list[MsgStatus] = []
+    status_result: list[MsgStatus] = []
     for endpoint in endpoints:
         try:
-            response = send_message(endpoint, env)
-            logger.info("Sent message to agent", extra={"agent_endpoint": endpoint})
-            result.append(
+            response = send_message(endpoint, env, sync=True)
+            status_result.append(
                 MsgStatus(
                     status=DeliveryStatus.SENT,
-                    detail=response.text,
+                    detail="Message sent successfully",
                     destination=destination,
                     endpoint=endpoint,
-                    session=env.session,
+                    session=session_id,
                 )
             )
+            break
         except requests.RequestException as e:
             logger.error("Failed to send message to agent", extra={"error": str(e)})
-            result.append(
+            status_result.append(
                 MsgStatus(
                     status=DeliveryStatus.FAILED,
                     detail=str(e),
@@ -154,4 +204,16 @@ def send_message_to_agent(
                     session=env.session,
                 )
             )
-    return result
+
+    logger.info("Sent message to agent", extra={"agent_endpoint": endpoint})
+
+    if sync:
+        try:
+            return parse_sync_response(response.text, response_type)
+        except ValidationError as e:
+            logger.error(
+                "Received invalid response envelope",
+                extra={"error": str(e), "response": response.text},
+            )
+
+    return status_result

{uagents_core-0.3.5 → uagents_core-0.3.7}/uagents_core/utils/resolver.py

@@ -75,17 +75,24 @@ def lookup_endpoint_for_agent(
 
 
 class AlmanacResolver(Resolver):
-    def __init__(self, agentverse_config: AgentverseConfig | None = None):
+    def __init__(
+        self, max_endpoints: int = 1, agentverse_config: AgentverseConfig | None = None
+    ):
         self.agentverse_config = agentverse_config or AgentverseConfig()
+        self.max_endpoints = max_endpoints
 
     async def resolve(self, destination: str) -> tuple[str | None, list[str]]:
         endpoints = lookup_endpoint_for_agent(
-            agent_identifier=destination, agentverse_config=self.agentverse_config
+            agent_identifier=destination,
+            max_endpoints=self.max_endpoints,
+            agentverse_config=self.agentverse_config,
         )
         return None, endpoints
 
     def sync_resolve(self, destination: str) -> list[str]:
         endpoints = lookup_endpoint_for_agent(
-            agent_identifier=destination, agentverse_config=self.agentverse_config
+            agent_identifier=destination,
+            max_endpoints=self.max_endpoints,
+            agentverse_config=self.agentverse_config,
         )
         return endpoints