PyPI - solace-agent-mesh - Versions diffs - 1.7.1__py3-none-any.whl → 1.13.2__py3-none-any.whl - Mend

solace-agent-mesh 1.7.1py3-none-any.whl → 1.13.2py3-none-any.whl

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.

Potentially problematic release.

This version of solace-agent-mesh might be problematic. Click here for more details.

Files changed (447) hide show

solace_agent_mesh/client/webui/frontend/static/auth-callback.html CHANGED Viewed

@@ -5,9 +5,9 @@
         <link rel="icon" type="image/svg+xml" href="/assets/favicon-BLgzUch9.ico" />
         <meta name="viewport" content="width=device-width, initial-scale=1.0" />
         <title>Solace Agent Mesh</title>
-      <script type="module" crossorigin src="/assets/authCallback-tcIFZLis.js"></script>
-      <link rel="modulepreload" crossorigin href="/assets/vendor-CINwxvwV.js">
-      <link rel="modulepreload" crossorigin href="/assets/client-CRYdKo2Q.js">
+      <script type="module" crossorigin src="/assets/authCallback-KnKMP_vb.js"></script>
+      <link rel="modulepreload" crossorigin href="/assets/vendor-CGk8Suyh.js">
+      <link rel="modulepreload" crossorigin href="/assets/client-DpBL2stg.js">
     </head>
     <body>
         <div id="root"></div>

solace_agent_mesh/client/webui/frontend/static/index.html CHANGED Viewed

@@ -5,10 +5,10 @@
         <link rel="icon" type="image/svg+xml" href="/assets/favicon-BLgzUch9.ico" />
         <meta name="viewport" content="width=device-width, initial-scale=1.0" />
         <title>Solace Agent Mesh</title>
-      <script type="module" crossorigin src="/assets/main-ILja9MCG.js"></script>
-      <link rel="modulepreload" crossorigin href="/assets/vendor-CINwxvwV.js">
-      <link rel="modulepreload" crossorigin href="/assets/client-CRYdKo2Q.js">
-      <link rel="stylesheet" crossorigin href="/assets/main-CojeY_1w.css">
+      <script type="module" crossorigin src="/assets/main-Cd498TV2.js"></script>
+      <link rel="modulepreload" crossorigin href="/assets/vendor-CGk8Suyh.js">
+      <link rel="modulepreload" crossorigin href="/assets/client-DpBL2stg.js">
+      <link rel="stylesheet" crossorigin href="/assets/main-rSf8Vu29.css">
     </head>
     <body>
         <div id="root"></div>

solace_agent_mesh/client/webui/frontend/static/mockServiceWorker.js ADDED Viewed

@@ -0,0 +1,336 @@
+/* eslint-disable */
+/* tslint:disable */
+/**
+ * Mock Service Worker.
+ * @see https://github.com/mswjs/msw
+ * - Please do NOT modify this file.
+ */
+const PACKAGE_VERSION = "2.12.3";
+const INTEGRITY_CHECKSUM = "4db4a41e972cec1b64cc569c66952d82";
+const IS_MOCKED_RESPONSE = Symbol("isMockedResponse");
+const activeClientIds = new Set();
+addEventListener("install", function () {
+    self.skipWaiting();
+});
+addEventListener("activate", function (event) {
+    event.waitUntil(self.clients.claim());
+});
+addEventListener("message", async function (event) {
+    const clientId = Reflect.get(event.source || {}, "id");
+    if (!clientId || !self.clients) {
+        return;
+    }
+    const client = await self.clients.get(clientId);
+    if (!client) {
+        return;
+    }
+    const allClients = await self.clients.matchAll({
+        type: "window",
+    });
+    switch (event.data) {
+        case "KEEPALIVE_REQUEST": {
+            sendToClient(client, {
+                type: "KEEPALIVE_RESPONSE",
+            });
+            break;
+        }
+        case "INTEGRITY_CHECK_REQUEST": {
+            sendToClient(client, {
+                type: "INTEGRITY_CHECK_RESPONSE",
+                payload: {
+                    packageVersion: PACKAGE_VERSION,
+                    checksum: INTEGRITY_CHECKSUM,
+                },
+            });
+            break;
+        }
+        case "MOCK_ACTIVATE": {
+            activeClientIds.add(clientId);
+            sendToClient(client, {
+                type: "MOCKING_ENABLED",
+                payload: {
+                    client: {
+                        id: client.id,
+                        frameType: client.frameType,
+                    },
+                },
+            });
+            break;
+        }
+        case "CLIENT_CLOSED": {
+            activeClientIds.delete(clientId);
+            const remainingClients = allClients.filter(client => {
+                return client.id !== clientId;
+            });
+            // Unregister itself when there are no more clients
+            if (remainingClients.length === 0) {
+                self.registration.unregister();
+            }
+            break;
+        }
+    }
+});
+addEventListener("fetch", function (event) {
+    const requestInterceptedAt = Date.now();
+    // Bypass navigation requests.
+    if (event.request.mode === "navigate") {
+        return;
+    }
+    // Opening the DevTools triggers the "only-if-cached" request
+    // that cannot be handled by the worker. Bypass such requests.
+    if (event.request.cache === "only-if-cached" && event.request.mode !== "same-origin") {
+        return;
+    }
+    // Bypass all requests when there are no active clients.
+    // Prevents the self-unregistered worked from handling requests
+    // after it's been terminated (still remains active until the next reload).
+    if (activeClientIds.size === 0) {
+        return;
+    }
+    const requestId = crypto.randomUUID();
+    event.respondWith(handleRequest(event, requestId, requestInterceptedAt));
+});
+/**
+ * @param {FetchEvent} event
+ * @param {string} requestId
+ * @param {number} requestInterceptedAt
+ */
+async function handleRequest(event, requestId, requestInterceptedAt) {
+    const client = await resolveMainClient(event);
+    const requestCloneForEvents = event.request.clone();
+    const response = await getResponse(event, client, requestId, requestInterceptedAt);
+    // Send back the response clone for the "response:*" life-cycle events.
+    // Ensure MSW is active and ready to handle the message, otherwise
+    // this message will pend indefinitely.
+    if (client && activeClientIds.has(client.id)) {
+        const serializedRequest = await serializeRequest(requestCloneForEvents);
+        // Clone the response so both the client and the library could consume it.
+        const responseClone = response.clone();
+        sendToClient(
+            client,
+            {
+                type: "RESPONSE",
+                payload: {
+                    isMockedResponse: IS_MOCKED_RESPONSE in response,
+                    request: {
+                        id: requestId,
+                        ...serializedRequest,
+                    },
+                    response: {
+                        type: responseClone.type,
+                        status: responseClone.status,
+                        statusText: responseClone.statusText,
+                        headers: Object.fromEntries(responseClone.headers.entries()),
+                        body: responseClone.body,
+                    },
+                },
+            },
+            responseClone.body ? [serializedRequest.body, responseClone.body] : []
+        );
+    }
+    return response;
+}
+/**
+ * Resolve the main client for the given event.
+ * Client that issues a request doesn't necessarily equal the client
+ * that registered the worker. It's with the latter the worker should
+ * communicate with during the response resolving phase.
+ * @param {FetchEvent} event
+ * @returns {Promise<Client | undefined>}
+ */
+async function resolveMainClient(event) {
+    const client = await self.clients.get(event.clientId);
+    if (activeClientIds.has(event.clientId)) {
+        return client;
+    }
+    if (client?.frameType === "top-level") {
+        return client;
+    }
+    const allClients = await self.clients.matchAll({
+        type: "window",
+    });
+    return allClients
+        .filter(client => {
+            // Get only those clients that are currently visible.
+            return client.visibilityState === "visible";
+        })
+        .find(client => {
+            // Find the client ID that's recorded in the
+            // set of clients that have registered the worker.
+            return activeClientIds.has(client.id);
+        });
+}
+/**
+ * @param {FetchEvent} event
+ * @param {Client | undefined} client
+ * @param {string} requestId
+ * @param {number} requestInterceptedAt
+ * @returns {Promise<Response>}
+ */
+async function getResponse(event, client, requestId, requestInterceptedAt) {
+    // Clone the request because it might've been already used
+    // (i.e. its body has been read and sent to the client).
+    const requestClone = event.request.clone();
+    function passthrough() {
+        // Cast the request headers to a new Headers instance
+        // so the headers can be manipulated with.
+        const headers = new Headers(requestClone.headers);
+        // Remove the "accept" header value that marked this request as passthrough.
+        // This prevents request alteration and also keeps it compliant with the
+        // user-defined CORS policies.
+        const acceptHeader = headers.get("accept");
+        if (acceptHeader) {
+            const values = acceptHeader.split(",").map(value => value.trim());
+            const filteredValues = values.filter(value => value !== "msw/passthrough");
+            if (filteredValues.length > 0) {
+                headers.set("accept", filteredValues.join(", "));
+            } else {
+                headers.delete("accept");
+            }
+        }
+        return fetch(requestClone, { headers });
+    }
+    // Bypass mocking when the client is not active.
+    if (!client) {
+        return passthrough();
+    }
+    // Bypass initial page load requests (i.e. static assets).
+    // The absence of the immediate/parent client in the map of the active clients
+    // means that MSW hasn't dispatched the "MOCK_ACTIVATE" event yet
+    // and is not ready to handle requests.
+    if (!activeClientIds.has(client.id)) {
+        return passthrough();
+    }
+    // Notify the client that a request has been intercepted.
+    const serializedRequest = await serializeRequest(event.request);
+    const clientMessage = await sendToClient(
+        client,
+        {
+            type: "REQUEST",
+            payload: {
+                id: requestId,
+                interceptedAt: requestInterceptedAt,
+                ...serializedRequest,
+            },
+        },
+        [serializedRequest.body]
+    );
+    switch (clientMessage.type) {
+        case "MOCK_RESPONSE": {
+            return respondWithMock(clientMessage.data);
+        }
+        case "PASSTHROUGH": {
+            return passthrough();
+        }
+    }
+    return passthrough();
+}
+/**
+ * @param {Client} client
+ * @param {any} message
+ * @param {Array<Transferable>} transferrables
+ * @returns {Promise<any>}
+ */
+function sendToClient(client, message, transferrables = []) {
+    return new Promise((resolve, reject) => {
+        const channel = new MessageChannel();
+        channel.port1.onmessage = event => {
+            if (event.data && event.data.error) {
+                return reject(event.data.error);
+            }
+            resolve(event.data);
+        };
+        client.postMessage(message, [channel.port2, ...transferrables.filter(Boolean)]);
+    });
+}
+/**
+ * @param {Response} response
+ * @returns {Response}
+ */
+function respondWithMock(response) {
+    // Setting response status code to 0 is a no-op.
+    // However, when responding with a "Response.error()", the produced Response
+    // instance will have status code set to 0. Since it's not possible to create
+    // a Response instance with status code 0, handle that use-case separately.
+    if (response.status === 0) {
+        return Response.error();
+    }
+    const mockedResponse = new Response(response.body, response);
+    Reflect.defineProperty(mockedResponse, IS_MOCKED_RESPONSE, {
+        value: true,
+        enumerable: true,
+    });
+    return mockedResponse;
+}
+/**
+ * @param {Request} request
+ */
+async function serializeRequest(request) {
+    return {
+        url: request.url,
+        mode: request.mode,
+        method: request.method,
+        headers: Object.fromEntries(request.headers.entries()),
+        cache: request.cache,
+        credentials: request.credentials,
+        destination: request.destination,
+        integrity: request.integrity,
+        redirect: request.redirect,
+        referrer: request.referrer,
+        referrerPolicy: request.referrerPolicy,
+        body: await request.arrayBuffer(),
+        keepalive: request.keepalive,
+    };
+}

solace_agent_mesh/client/webui/frontend/static/ui-version.json ADDED Viewed

@@ -0,0 +1,6 @@
+{
+  "id": "@SolaceLabs/solace-agent-mesh-ui",
+  "name": "Solace Agent Mesh UI",
+  "description": "Solace Agent Mesh UI components - React library for building agent communication interfaces",
+  "version": "1.30.4"
+}

solace_agent_mesh/common/a2a/types.py CHANGED Viewed

@@ -34,7 +34,7 @@ class ArtifactInfo(BaseModel):
     schema_definition: Optional[Dict[str, Any]] = Field(default=None, alias="schema")
     uri: Optional[str] = None
     version: Optional[Union[int, str]] = None
-    version_count: int
+    version_count: Optional[int] = None
     source: Optional[str] = None  # Optional: Source of the artifact (e.g., "project")
     model_config = ConfigDict(populate_by_name=True)

solace_agent_mesh/common/agent_registry.py CHANGED Viewed

@@ -12,17 +12,28 @@ from a2a.types import AgentCard
 log = logging.getLogger(__name__)
 class AgentRegistry:
     """Stores and manages discovered AgentCards with health tracking."""
-    def __init__(self):
+    def __init__(self, on_agent_added=None, on_agent_removed=None):
         self._agents: Dict[str, AgentCard] = {}
         self._last_seen: Dict[str, float] = {}  # Timestamp of last agent card received
         self._lock = threading.Lock()
+        self._on_agent_added = on_agent_added
+        self._on_agent_removed = on_agent_removed
+    def set_on_agent_added_callback(self, callback):
+        """Sets the callback function to be called when a new agent is added."""
+        self._on_agent_added = callback
+    def set_on_agent_removed_callback(self, callback):
+        """Sets the callback function to be called when an agent is removed."""
+        self._on_agent_removed = callback
     def add_or_update_agent(self, agent_card: AgentCard):
         """Adds a new agent or updates an existing one."""
         if not agent_card or not agent_card.name:
             log.warning("Attempted to register agent with invalid agent card or missing name")
             return False
@@ -30,12 +41,19 @@ class AgentRegistry:
         with self._lock:
             is_new = agent_card.name not in self._agents
             current_time = time.time()
             # Store the agent information
             self._agents[agent_card.name] = agent_card
             self._last_seen[agent_card.name] = current_time
-            return is_new
+        # Call callback OUTSIDE the lock to avoid deadlock
+        if is_new and self._on_agent_added:
+            try:
+                self._on_agent_added(agent_card)
+            except Exception as e:
+                log.error(f"Error in agent added callback for {agent_card.name}: {e}", exc_info=True)
+        return is_new
     def get_agent(self, agent_name: str) -> Optional[AgentCard]:
         """Retrieves an agent card by name."""
@@ -88,14 +106,14 @@ class AgentRegistry:
     def remove_agent(self, agent_name: str) -> bool:
         """Removes an agent from the registry."""
         with self._lock:
             if agent_name in self._agents:
                 # Get agent details before removal for logging
                 last_seen_time = self._last_seen.get(agent_name)
                 current_time = time.time()
                 time_since_last_seen = int(current_time - last_seen_time) if last_seen_time else "unknown"
                 # Log detailed information about the agent being removed
                 log.warning(
                     "AGENT DE-REGISTRATION: Removing agent '%s' from registry. "
@@ -103,17 +121,26 @@ class AgentRegistry:
                     agent_name,
                     time_since_last_seen
                 )
                 # Remove the agent from all tracking dictionaries
                 del self._agents[agent_name]
                 if agent_name in self._last_seen:
                     del self._last_seen[agent_name]
                 log.info("Agent '%s' successfully removed from registry", agent_name)
-                return True
+                removed = True
             else:
                 log.debug("Attempted to remove non-existent agent '%s' from registry", agent_name)
-                return False
+                removed = False
+        # Call callback OUTSIDE the lock to avoid deadlock
+        if removed and self._on_agent_removed:
+            try:
+                self._on_agent_removed(agent_name)
+            except Exception as e:
+                log.error(f"Error in agent removed callback for {agent_name}: {e}", exc_info=True)
+        return removed
     def clear(self):
         """Clears all registered agents."""

solace_agent_mesh/common/data_parts.py CHANGED Viewed

@@ -92,6 +92,33 @@ class ArtifactCreationProgressData(BaseModel):
         None,
         description="The version number of the artifact being created or updated.",
     )
+    function_call_id: Optional[str] = Field(
+        None, description="The function call ID if artifact was created by a tool."
+    )
+class ArtifactSavedData(BaseModel):
+    """
+    Data model for an artifact saved notification signal.
+    This is sent when an artifact has been successfully saved to storage.
+    Unlike ArtifactCreationProgressData, this is a single notification event
+    and does not follow the start->updates->end protocol.
+    """
+    type: Literal["artifact_saved"] = Field(
+        "artifact_saved",
+        description="The constant type for this data part.",
+    )
+    filename: str = Field(..., description="The name of the saved artifact.")
+    version: int = Field(..., description="The version number of the saved artifact.")
+    mime_type: str = Field(..., description="The MIME type of the artifact.")
+    size_bytes: int = Field(..., description="The size of the artifact in bytes.")
+    description: Optional[str] = Field(
+        None, description="An optional description of the artifact."
+    )
+    function_call_id: Optional[str] = Field(
+        None, description="The function call ID if artifact was created by a tool."
+    )
 class ToolResultData(BaseModel):
@@ -114,10 +141,107 @@ class ToolResultData(BaseModel):
     )
+class TemplateBlockData(BaseModel):
+    """
+    Data model for a buffered inline template block ready for resolution.
+    Corresponds to template_block.json schema.
+    """
+    type: Literal["template_block"] = Field(
+        "template_block", description="The constant type for this data part."
+    )
+    template_id: str = Field(
+        ..., description="UUID for tracking this specific template instance."
+    )
+    data_artifact: str = Field(
+        ..., description="Data artifact filename or filename:version."
+    )
+    jsonpath: Optional[str] = Field(
+        None, description="Optional JSONPath expression to filter data."
+    )
+    limit: Optional[int] = Field(
+        None, description="Optional limit on number of items/rows to pass to template."
+    )
+    template_content: str = Field(
+        ..., description="The full Liquid template content."
+    )
+class DeepResearchProgressData(BaseModel):
+    """
+    Data model for deep research progress updates with structured information.
+    Provides detailed progress for UI visualization during iterative research.
+    """
+    type: Literal["deep_research_progress"] = Field(
+        "deep_research_progress", description="The constant type for this data part."
+    )
+    phase: str = Field(..., description="Current phase: planning, searching, analyzing, writing")
+    status_text: str = Field(..., description="Human-readable status message")
+    progress_percentage: int = Field(..., description="Overall progress percentage (0-100)")
+    current_iteration: int = Field(..., description="Current iteration number")
+    total_iterations: int = Field(..., description="Total planned iterations")
+    sources_found: int = Field(..., description="Total sources found so far")
+    current_query: str = Field(default="", description="Current search query being executed")
+    fetching_urls: list[Dict[str, str]] = Field(
+        default_factory=list,
+        description="List of sources being analyzed (with title, favicon/icon, and source_type)"
+    )
+    elapsed_seconds: int = Field(..., description="Elapsed time in seconds")
+    max_runtime_seconds: int = Field(default=0, description="Maximum runtime limit (0 = no limit)")
+class RAGInfoUpdateData(BaseModel):
+    """
+    Data model for RAG info panel updates during deep research.
+    Sends title and sources to the UI early so the RAG info panel can display them
+    while research is still in progress.
+    """
+    type: Literal["rag_info_update"] = Field(
+        "rag_info_update", description="The constant type for this data part."
+    )
+    title: str = Field(..., description="Human-readable title for the research (generated by LLM)")
+    query: str = Field(..., description="The original research question/query")
+    search_type: str = Field(default="deep_research", description="Type of search (deep_research, web_search, etc.)")
+    sources: list[Dict[str, Any]] = Field(
+        default_factory=list,
+        description="List of sources found so far (in camelCase format for frontend)"
+    )
+    is_complete: bool = Field(default=False, description="Whether the research is complete")
+    timestamp: str = Field(..., description="ISO timestamp of this update")
+class DeepResearchReportData(BaseModel):
+    """
+    Data model for a deep research report completion signal.
+    This is sent when a deep research report artifact has been created and saved.
+    The frontend will use this to render the DeepResearchReportBubble component
+    instead of displaying the report content inline.
+    This signal bypasses the LLM response entirely, ensuring the report is displayed
+    via the artifact viewer without duplication.
+    """
+    type: Literal["deep_research_report"] = Field(
+        "deep_research_report", description="The constant type for this data part."
+    )
+    filename: str = Field(..., description="The filename of the research report artifact.")
+    version: int = Field(..., description="The version number of the artifact.")
+    uri: str = Field(..., description="The artifact URI for fetching the report content.")
+    title: Optional[str] = Field(None, description="Human-readable title for the research.")
+    sources_count: int = Field(default=0, description="Number of sources analyzed.")
 SignalData = Union[
     ToolInvocationStartData,
     LlmInvocationData,
     AgentProgressUpdateData,
     ArtifactCreationProgressData,
+    ArtifactSavedData,
     ToolResultData,
+    TemplateBlockData,
+    DeepResearchProgressData,
+    RAGInfoUpdateData,
+    DeepResearchReportData,
 ]

solace-agent-mesh 1.7.1__py3-none-any.whl → 1.13.2__py3-none-any.whl

Potentially problematic release.

solace-agent-mesh 1.7.1py3-none-any.whl → 1.13.2py3-none-any.whl