solace-agent-mesh 0.2.4__py3-none-any.whl → 1.0.2__py3-none-any.whl

solace_agent_mesh/common/types.py

@@ -0,0 +1,411 @@
+from pydantic import BaseModel, Field, TypeAdapter, field_validator
+from typing import Literal, List, Annotated, Optional, Union, Dict, Any, TypedDict
+from datetime import datetime, timezone
+from pydantic import model_validator, ConfigDict, field_serializer
+from uuid import uuid4
+from enum import Enum
+from typing_extensions import Self
+
+
+class TaskState(str, Enum):
+    SUBMITTED = "submitted"
+    WORKING = "working"
+    INPUT_REQUIRED = "input-required"
+    COMPLETED = "completed"
+    CANCELED = "canceled"
+    FAILED = "failed"
+    UNKNOWN = "unknown"
+
+
+class TextPart(BaseModel):
+    type: Literal["text"] = "text"
+    text: str
+    metadata: dict[str, Any] | None = None
+
+
+class FileContent(BaseModel):
+    name: str | None = None
+    mimeType: str | None = None
+    bytes: str | None = None
+    uri: str | None = None
+
+    @model_validator(mode="after")
+    def check_content(self) -> Self:
+        if not (self.bytes or self.uri):
+            raise ValueError("Either 'bytes' or 'uri' must be present in the file data")
+        if self.bytes and self.uri:
+            raise ValueError(
+                "Only one of 'bytes' or 'uri' can be present in the file data"
+            )
+        return self
+
+
+class FilePart(BaseModel):
+    type: Literal["file"] = "file"
+    file: FileContent
+    metadata: dict[str, Any] | None = None
+
+
+class DataPart(BaseModel):
+    type: Literal["data"] = "data"
+    data: dict[str, Any]
+    metadata: dict[str, Any] | None = None
+
+
+Part = Annotated[Union[TextPart, FilePart, DataPart], Field(discriminator="type")]
+
+
+class Message(BaseModel):
+    role: Literal["user", "agent"]
+    parts: List[Part]
+    metadata: dict[str, Any] | None = None
+
+
+class TaskStatus(BaseModel):
+    state: TaskState
+    message: Message | None = None
+    timestamp: datetime = Field(default_factory=lambda: datetime.now(timezone.utc))
+
+    @field_serializer("timestamp")
+    def serialize_dt(self, dt: datetime, _info):
+        return dt.isoformat()
+
+
+class Artifact(BaseModel):
+    name: str | None = None
+    description: str | None = None
+    parts: List[Part]
+    metadata: dict[str, Any] | None = None
+    index: int = 0
+    append: bool | None = None
+    lastChunk: bool | None = None
+
+
+class Task(BaseModel):
+    id: str
+    sessionId: str | None = None
+    status: TaskStatus
+    artifacts: List[Artifact] | None = None
+    history: List[Message] | None = None
+    metadata: dict[str, Any] | None = None
+
+
+class TaskStatusUpdateEvent(BaseModel):
+    id: str
+    status: TaskStatus
+    final: bool = False
+    metadata: dict[str, Any] | None = None
+
+
+class TaskArtifactUpdateEvent(BaseModel):
+    id: str
+    artifact: Artifact
+    metadata: dict[str, Any] | None = None
+
+
+class AuthenticationInfo(BaseModel):
+    model_config = ConfigDict(extra="allow")
+
+    schemes: List[str]
+    credentials: str | None = None
+
+
+class PushNotificationConfig(BaseModel):
+    url: str
+    token: str | None = None
+    authentication: AuthenticationInfo | None = None
+
+
+class TaskIdParams(BaseModel):
+    id: str
+    metadata: dict[str, Any] | None = None
+
+
+class TaskQueryParams(TaskIdParams):
+    historyLength: int | None = None
+
+
+class TaskSendParams(BaseModel):
+    id: str
+    sessionId: str = Field(default_factory=lambda: uuid4().hex)
+    message: Message
+    acceptedOutputModes: Optional[List[str]] = None
+    pushNotification: PushNotificationConfig | None = None
+    historyLength: int | None = None
+    metadata: dict[str, Any] | None = None
+
+
+class TaskPushNotificationConfig(BaseModel):
+    id: str
+    pushNotificationConfig: PushNotificationConfig
+
+
+class ParallelToolCallInfo(TypedDict):
+    """
+    A dictionary structure to hold information about parallel tool calls within a single turn.
+    """
+
+    total: int
+    completed: int
+    results: List[Dict[str, Any]]
+
+
+## RPC Messages
+
+
+class JSONRPCMessage(BaseModel):
+    jsonrpc: Literal["2.0"] = "2.0"
+    id: int | str | None = Field(default_factory=lambda: uuid4().hex)
+
+
+class JSONRPCRequest(JSONRPCMessage):
+    method: str
+    params: dict[str, Any] | None = None
+
+
+class JSONRPCError(BaseModel):
+    code: int
+    message: str
+    data: Any | None = None
+
+
+class JSONRPCResponse(JSONRPCMessage):
+    result: Any | None = None
+    error: JSONRPCError | None = None
+
+
+class SendTaskRequest(JSONRPCRequest):
+    method: Literal["tasks/send"] = "tasks/send"
+    params: TaskSendParams
+
+
+class SendTaskResponse(JSONRPCResponse):
+    result: Task | None = None
+
+
+class SendTaskStreamingRequest(JSONRPCRequest):
+    method: Literal["tasks/sendSubscribe"] = "tasks/sendSubscribe"
+    params: TaskSendParams
+
+
+class SendTaskStreamingResponse(JSONRPCResponse):
+    result: TaskStatusUpdateEvent | TaskArtifactUpdateEvent | None = None
+
+
+class GetTaskRequest(JSONRPCRequest):
+    method: Literal["tasks/get"] = "tasks/get"
+    params: TaskQueryParams
+
+
+class GetTaskResponse(JSONRPCResponse):
+    result: Task | None = None
+
+
+class CancelTaskRequest(JSONRPCRequest):
+    method: Literal["tasks/cancel",] = "tasks/cancel"
+    params: TaskIdParams
+
+
+class CancelTaskResponse(JSONRPCResponse):
+    result: Task | None = None
+
+
+class SetTaskPushNotificationRequest(JSONRPCRequest):
+    method: Literal["tasks/pushNotification/set",] = "tasks/pushNotification/set"
+    params: TaskPushNotificationConfig
+
+
+class SetTaskPushNotificationResponse(JSONRPCResponse):
+    result: TaskPushNotificationConfig | None = None
+
+
+class GetTaskPushNotificationRequest(JSONRPCRequest):
+    method: Literal["tasks/pushNotification/get",] = "tasks/pushNotification/get"
+    params: TaskIdParams
+
+
+class GetTaskPushNotificationResponse(JSONRPCResponse):
+    result: TaskPushNotificationConfig | None = None
+
+
+class TaskResubscriptionRequest(JSONRPCRequest):
+    method: Literal["tasks/resubscribe",] = "tasks/resubscribe"
+    params: TaskIdParams
+
+
+A2ARequest = TypeAdapter(
+    Annotated[
+        Union[
+            SendTaskRequest,
+            GetTaskRequest,
+            CancelTaskRequest,
+            SetTaskPushNotificationRequest,
+            GetTaskPushNotificationRequest,
+            TaskResubscriptionRequest,
+            SendTaskStreamingRequest,
+        ],
+        Field(discriminator="method"),
+    ]
+)
+
+## Error types
+
+
+class JSONParseError(JSONRPCError):
+    code: int = -32700
+    message: str = "Invalid JSON payload"
+    data: Any | None = None
+
+
+class InvalidRequestError(JSONRPCError):
+    code: int = -32600
+    message: str = "Request payload validation error"
+    data: Any | None = None
+
+
+class MethodNotFoundError(JSONRPCError):
+    code: int = -32601
+    message: str = "Method not found"
+    data: None = None
+
+
+class InvalidParamsError(JSONRPCError):
+    code: int = -32602
+    message: str = "Invalid parameters"
+    data: Any | None = None
+
+
+class InternalError(JSONRPCError):
+    code: int = -32603
+    message: str = "Internal error"
+    data: Any | None = None
+
+
+class TaskNotFoundError(JSONRPCError):
+    code: int = -32001
+    message: str = "Task not found"
+    data: None = None
+
+
+class TaskNotCancelableError(JSONRPCError):
+    code: int = -32002
+    message: str = "Task cannot be canceled"
+    data: None = None
+
+
+class PushNotificationNotSupportedError(JSONRPCError):
+    code: int = -32003
+    message: str = "Push Notification is not supported"
+    data: None = None
+
+
+class UnsupportedOperationError(JSONRPCError):
+    code: int = -32004
+    message: str = "This operation is not supported"
+    data: None = None
+
+
+class ContentTypeNotSupportedError(JSONRPCError):
+    code: int = -32005
+    message: str = "Incompatible content types"
+    data: None = None
+
+
+class AgentProvider(BaseModel):
+    organization: str
+    url: str | None = None
+
+
+class AgentCapabilities(BaseModel):
+    streaming: bool = False
+    pushNotifications: bool = False
+    stateTransitionHistory: bool = False
+
+
+class AgentAuthentication(BaseModel):
+    schemes: List[str]
+    credentials: str | None = None
+
+
+class AgentSkill(BaseModel):
+    id: str
+    name: str
+    description: str | None = None
+    tags: List[str] | None = None
+    examples: List[str] | None = None
+    inputModes: List[str] | None = None
+    outputModes: List[str] | None = None
+
+
+class AgentCard(BaseModel):
+    name: str
+    display_name: str | None = None
+    description: str | None = None
+    url: str
+    provider: AgentProvider | None = None
+    version: str
+    documentationUrl: str | None = None
+    capabilities: AgentCapabilities
+    authentication: AgentAuthentication | None = None
+    defaultInputModes: List[str] = ["text"]
+    defaultOutputModes: List[str] = ["text"]
+    skills: List[AgentSkill]
+    tools: Optional[List[AgentSkill]] = None
+    peer_agents: Dict[str, "AgentCard"]
+
+
+class ArtifactInfo(BaseModel):
+    """
+    Represents information about an artifact, typically for listing or display.
+    Mirrors the frontend ArtifactInfo type and the model used in artifact_helpers.py.
+    """
+
+    filename: str
+    mime_type: Optional[str] = None
+    size: int
+    last_modified: Optional[str] = None
+    description: Optional[str] = None
+    schema_definition: Optional[Dict[str, Any]] = Field(default=None, alias="schema")
+    uri: Optional[str] = None
+    version: Optional[Union[int, str]] = None
+    version_count: int
+
+    model_config = ConfigDict(populate_by_name=True)
+
+    @field_validator("version")
+    @classmethod
+    def validate_version_string(cls, v: Union[int, str]) -> Union[int, str]:
+        if isinstance(v, str):
+            if v.lower() == "latest":
+                return v
+            try:
+                int(v)
+                return v
+            except ValueError:
+                raise ValueError(
+                    f"String version must be 'latest' or a valid integer representation. Got: '{v}'"
+                )
+        return v
+
+
+class A2AClientError(Exception):
+    pass
+
+
+class A2AClientHTTPError(A2AClientError):
+    def __init__(self, status_code: int, message: str):
+        self.status_code = status_code
+        self.message = message
+        super().__init__(f"HTTP Error {status_code}: {message}")
+
+
+class A2AClientJSONError(A2AClientError):
+    def __init__(self, message: str):
+        self.message = message
+        super().__init__(f"JSON Error: {message}")
+
+
+class MissingAPIKeyError(Exception):
+    """Exception for missing API key."""
+
+    pass

solace_agent_mesh/common/utils/__init__.py

@@ -0,0 +1,7 @@
+"""Shared utility functions."""
+
+from .mime_helpers import is_text_based_mime_type
+
+__all__ = [
+    "is_text_based_mime_type",
+]

solace_agent_mesh/common/utils/asyncio_macos_fix.py

@@ -0,0 +1,86 @@
+"""
+Minimal asyncio fix for macOS subprocess creation issues.
+
+This module provides a targeted fix for the NotImplementedError that occurs when
+creating subprocesses with asyncio on macOS with Python 3.11+.
+
+The issue occurs because the default event loop policy on macOS doesn't implement
+get_child_watcher(), which is required for subprocess creation.
+"""
+
+import sys
+from solace_ai_connector.common.log import log
+
+
+def apply_macos_asyncio_fix() -> bool:
+    """
+    Apply minimal asyncio fix for macOS subprocess support.
+
+    This fix specifically addresses the NotImplementedError in
+    asyncio.events.get_child_watcher() by providing a ThreadedChildWatcher
+    implementation that works on macOS.
+
+    Returns:
+        bool: True if fix was applied or not needed, False if fix failed.
+    """
+    if sys.platform != "darwin" and sys.platform != "linux":
+        log.debug("Not on macOS or linux, asyncio fix not needed.")
+        return True
+
+    import asyncio
+
+    log.info(
+        "On macOS. Applying asyncio child watcher fix for Python %s",
+        sys.version.split()[0],
+    )
+
+    try:
+        import asyncio.events
+        from asyncio.unix_events import ThreadedChildWatcher
+
+        if not hasattr(asyncio.events, "_original_get_child_watcher_by_solace_fix"):
+            if hasattr(asyncio.events.get_child_watcher, "__name__") and (
+                asyncio.events.get_child_watcher.__name__ == "get_child_watcher"
+                or asyncio.events.get_child_watcher.__name__
+                == "patched_get_child_watcher"
+            ):
+                asyncio.events._original_get_child_watcher_by_solace_fix = (
+                    asyncio.events.get_child_watcher
+                )
+
+        def patched_get_child_watcher():
+            """Returns a ThreadedChildWatcher that works on macOS."""
+            return ThreadedChildWatcher()
+
+        asyncio.events.get_child_watcher = patched_get_child_watcher
+
+        test_watcher = asyncio.events.get_child_watcher()
+        log.info(
+            "Successfully applied asyncio fix. get_child_watcher is now patched to use %s.",
+            type(test_watcher).__name__,
+        )
+        return True
+
+    except ImportError as e_imp:
+        log.error(
+            "Failed to import necessary asyncio modules for macOS fix: %s. This is unexpected.",
+            e_imp,
+        )
+        return False
+    except Exception as e:
+        log.error("Failed to apply unconditional asyncio fix for macOS: %s", e)
+        return False
+
+
+def ensure_asyncio_compatibility():
+    """
+    Ensure asyncio compatibility for subprocess creation on macOS.
+    This function should be called as early as possible in the application.
+
+    Returns:
+        bool: True if compatibility is ensured, False otherwise.
+    """
+    return apply_macos_asyncio_fix()
+
+
+ensure_asyncio_compatibility()

solace_agent_mesh/common/utils/embeds/__init__.py

@@ -0,0 +1,33 @@
+"""
+Exports key functions and constants for embed processing.
+"""
+
+from .constants import (
+    EMBED_DELIMITER_OPEN,
+    EMBED_DELIMITER_CLOSE,
+    EMBED_TYPE_SEPARATOR,
+    EMBED_FORMAT_SEPARATOR,
+    EMBED_CHAIN_DELIMITER,
+    EMBED_REGEX,
+    EARLY_EMBED_TYPES,
+    LATE_EMBED_TYPES,
+)
+from .resolver import (
+    evaluate_embed,
+    resolve_embeds_in_string,
+    resolve_embeds_recursively_in_string,
+)
+
+__all__ = [
+    "evaluate_embed",
+    "resolve_embeds_in_string",
+    "resolve_embeds_recursively_in_string",
+    "EMBED_DELIMITER_OPEN",
+    "EMBED_DELIMITER_CLOSE",
+    "EMBED_TYPE_SEPARATOR",
+    "EMBED_FORMAT_SEPARATOR",
+    "EMBED_CHAIN_DELIMITER",
+    "EMBED_REGEX",
+    "EARLY_EMBED_TYPES",
+    "LATE_EMBED_TYPES",
+]

solace_agent_mesh/common/utils/embeds/constants.py

@@ -0,0 +1,55 @@
+"""
+Constants used for embed parsing and processing.
+"""
+
+import re
+from typing import Set
+
+EMBED_DELIMITER_OPEN = "«"
+EMBED_DELIMITER_CLOSE = "»"
+EMBED_TYPE_SEPARATOR = ":"
+EMBED_FORMAT_SEPARATOR = "|"
+EMBED_CHAIN_DELIMITER = ">>>"
+
+# Regex to find potential embeds: «type:expression | format» or «type:expression»
+# - Group 1: type (alphanumeric, underscore)
+# - Group 2: expression (non-greedy match until | or »)
+# - Group 3: (Optional) format specifier (non-greedy match until »)
+EMBED_REGEX = re.compile(
+    re.escape(EMBED_DELIMITER_OPEN)
+    + r"([a-zA-Z0-9_]+)"  # 1: type
+    + re.escape(EMBED_TYPE_SEPARATOR)
+    + r"(.*?)"  # 2: expression
+    + r"(?:"  # Start optional non-capturing group for format
+    + r"\s*"  # Optional whitespace before format separator
+    + re.escape(EMBED_FORMAT_SEPARATOR)
+    + r"\s*"  # Optional whitespace after format separator
+    + r"(.*?)"  # 3: format specifier
+    + r")?"  # End optional non-capturing group
+    + re.escape(EMBED_DELIMITER_CLOSE)
+)
+
+EARLY_EMBED_TYPES: Set[str] = {
+    "math",
+    "datetime",
+    "uuid",
+    "artifact_meta",
+    "status_update",
+}
+LATE_EMBED_TYPES: Set[str] = {
+    "artifact_content",
+}
+
+TEXT_CONTAINER_MIME_TYPES: Set[str] = {
+    "text/plain",
+    "text/markdown",
+    "text/html",
+    "application/json",
+    "application/yaml",
+    "text/yaml",
+    "application/x-yaml",
+    "text/x-yaml",
+    "application/xml",
+    "text/xml",
+    "text/csv",
+}