jvserve 2.0.13__py3-none-any.whl → 2.0.15__py3-none-any.whl

jvserve/__init__.py

@@ -4,5 +4,5 @@ jvserve package initialization.
 This package provides the webserver for loading and interacting with JIVAS agents.
 """
 
-__version__ = "2.0.13"
+__version__ = "2.0.15"
 __supported__jivas__versions__ = ["2.0.0"]

jvserve/lib/agent_interface.py

@@ -159,77 +159,211 @@ class AgentInterface:
 
         return response
 
+    @staticmethod
+    def get_action_data(agent_id: str, action_label: str) -> dict:
+        """Retrieves the data for a specific action of an agent."""
+
+        action_data = {}
+        ctx = AgentInterface.load_context()
+
+        if not ctx:
+            return {}
+
+        # TODO : raise error in the event agent id is invalid
+        AgentInterface.LOGGER.debug(
+            f"attempting to interact with agent {agent_id} with user root {ctx.root}..."
+        )
+
+        try:
+            actions = _Jac.spawn_call(
+                ctx.entry_node.architype,
+                AgentInterface.spawn_walker(
+                    walker_name="list_actions",
+                    attributes={"agent_id": agent_id},
+                    module_name="agent.action.list_actions",
+                ),
+            ).actions
+
+            if actions:
+                for action in actions:
+                    if action.get("label") == action_label:
+                        action_data = action
+                        break
+
+        except Exception as e:
+            AgentInterface.EXPIRATION = None
+            AgentInterface.LOGGER.error(
+                f"an exception occurred: {e}, {traceback.format_exc()}"
+            )
+
+        ctx.close()
+        return action_data
+
     @staticmethod
     async def action_walker_exec(
-        agent_id: str = Form(...),  # noqa: B008
-        module_root: str = Form(...),  # noqa: B008
-        walker: str = Form(...),  # noqa: B008
+        agent_id: Optional[str] = Form(None),  # noqa: B008
+        action: Optional[str] = Form(None),  # noqa: B008
+        walker: Optional[str] = Form(None),  # noqa: B008
         args: Optional[str] = Form(None),  # noqa: B008
         attachments: List[UploadFile] = File(default_factory=list),  # noqa: B008
     ) -> JSONResponse:
-        """Execute a named walker exposed by an action within context; capable of handling JSON or file data depending on request"""
+        """
+        Execute a named walker exposed by an action within context.
+        Capable of handling JSON or file data depending on request.
+
+        Args:
+            agent_id: ID of the agent
+            action: Name of the action
+            walker: Name of the walker to execute
+            args: JSON string of additional arguments
+            attachments: List of uploaded files
+
+        Returns:
+            JSONResponse: Response containing walker output or error message
+        """
+        ctx = None
+        try:
+            # Validate required parameters
+            if walker is None or agent_id is None or action is None:
+                AgentInterface.LOGGER.error("Missing required parameters")
+                return JSONResponse(
+                    status_code=400,  # 400 (Bad Request)
+                    content={"error": "Missing required parameters"},
+                )
 
-        response = JSONResponse(status_code=500, content="unable to complete request")
+            # Get action data to resolve module
+            if agent_id is None or action is None:
+                AgentInterface.LOGGER.error("agent_id and action must not be None")
+                return JSONResponse(
+                    status_code=400,
+                    content={"error": "agent_id and action must not be None"},
+                )
 
-        try:
+            action_data = AgentInterface.get_action_data(agent_id, action)
+            if not action_data:
+                AgentInterface.LOGGER.error(
+                    f"Action {action} not found for agent {agent_id}"
+                )
+                return JSONResponse(
+                    status_code=404,
+                    content={"error": "Action not found"},
+                )
+
+            module_root = (
+                action_data.get("_package", {}).get("config", {}).get("module_root", "")
+            )
+            if not module_root:
+                AgentInterface.LOGGER.error(
+                    f"Module not found for action {action} of agent {agent_id}"
+                )
+                return JSONResponse(
+                    status_code=404,
+                    content={"error": "Module not found"},
+                )
+
+            # Load execution context
+            ctx = await AgentInterface.load_context_async()
+            if not ctx:
+                AgentInterface.LOGGER.error(f"Unable to execute {walker}")
+                return JSONResponse(
+                    status_code=500,
+                    content={"error": "Failed to load execution context"},
+                )
 
-            # add agent id as a standard
+            # Prepare attributes
             attributes: Dict[str, Any] = {"agent_id": agent_id}
 
-            # add any other args
+            # Parse additional arguments if provided
             if args:
-                attributes.update(json.loads(args))
+                try:
+                    attributes.update(json.loads(args))
+                except json.JSONDecodeError as e:
+                    AgentInterface.LOGGER.error(f"Invalid JSON in args: {e}")
+                    return JSONResponse(
+                        status_code=400,
+                        content={"error": "Invalid JSON in arguments"},
+                    )
 
-            # Processing files if any were uploaded
+            # Process uploaded files
             if attachments:
                 attributes["files"] = []
                 for file in attachments:
-                    attributes["files"].append(
-                        {
-                            "name": file.filename,
-                            "type": file.content_type,
-                            "content": await file.read(),
-                        }
-                    )
+                    try:
+                        attributes["files"].append(
+                            {
+                                "name": file.filename,
+                                "type": file.content_type,
+                                "content": await file.read(),
+                            }
+                        )
+                    except Exception as e:
+                        AgentInterface.LOGGER.error(
+                            f"Failed to process file {file.filename}: {e}"
+                        )
+                        continue  # Skip problematic files or return error if critical
 
-            if not agent_id or not walker or not module_root:
-                AgentInterface.LOGGER.error("missing parameters")
-                return JSONResponse(
-                    status_code=401, content="missing required parameters"
-                )
+            # Execute the walker
+            walker_response = _Jac.spawn_call(
+                ctx.entry_node.architype,
+                AgentInterface.spawn_walker(
+                    walker_name=walker,
+                    attributes=attributes,
+                    module_name=f"{module_root}.{walker}",
+                ),
+            ).response
 
-        except Exception as e:
-            AgentInterface.LOGGER.error(
-                f"an exception occurred: {e}, {traceback.format_exc()}"
-            )
-            return JSONResponse(status_code=500, content="internal server error")
+            # Handle different response types appropriately
+            try:
+                # If it's already a proper Response object, return as-is
+                if isinstance(walker_response, requests.Response):
+                    return walker_response
 
-        ctx = await AgentInterface.load_context_async()
-        if ctx:
-            # compose full module_path
-            module = f"{module_root}.{walker}"
+                # If it's a Pydantic model or similar complex object with dict representation
+                if hasattr(walker_response, "dict"):
+                    return JSONResponse(status_code=200, content=walker_response.dict())
 
-            try:
-                response = _Jac.spawn_call(
-                    ctx.entry_node.architype,
-                    AgentInterface.spawn_walker(
-                        walker_name=walker,
-                        attributes=attributes,
-                        module_name=module,
-                    ),
-                ).response
+                # If it's a list of complex objects
+                if (
+                    isinstance(walker_response, list)
+                    and len(walker_response) > 0
+                    and hasattr(walker_response[0], "dict")
+                ):
+                    return JSONResponse(
+                        status_code=200,
+                        content=[item.dict() for item in walker_response],
+                    )
+
+                # For other JSON-serializable types
+                try:
+                    return JSONResponse(status_code=200, content=walker_response)
+                except TypeError:
+                    # Fallback to string representation if not directly JSON-serializable
+                    return JSONResponse(
+                        status_code=200, content={"result": str(walker_response)}
+                    )
 
             except Exception as e:
-                AgentInterface.EXPIRATION = None
-                AgentInterface.LOGGER.error(
-                    f"an exception occurred: {e}, {traceback.format_exc()}"
+                AgentInterface.LOGGER.error(f"Failed to format walker response: {e}")
+                return JSONResponse(
+                    status_code=500,
+                    content={"error": "Failed to format response", "details": str(e)},
                 )
-        else:
-            AgentInterface.LOGGER.error(f"unable to execute {walker}")
 
-        ctx.close()
-
-        return response
+        except Exception as e:
+            AgentInterface.EXPIRATION = None
+            AgentInterface.LOGGER.error(
+                f"Exception occurred: {str(e)}\n{traceback.format_exc()}"
+            )
+            return JSONResponse(
+                status_code=500,
+                content={"error": "Internal server error", "details": str(e)},
+            )
+        finally:
+            if ctx:
+                try:
+                    ctx.close()
+                except Exception as e:
+                    AgentInterface.LOGGER.error(f"Error closing context: {str(e)}")
 
     class InteractPayload(BaseModel):
         """Payload for interacting with the agent."""

{jvserve-2.0.13.dist-info → jvserve-2.0.15.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: jvserve
-Version: 2.0.13
+Version: 2.0.15
 Summary: FastAPI webserver for loading and interaction with JIVAS agents.
 Home-page: https://github.com/TrueSelph/jvserve
 Author: TrueSelph Inc.

jvserve-2.0.15.dist-info/RECORD

@@ -0,0 +1,13 @@
+jvserve/__init__.py,sha256=S9zx3emgI3a17M2NmUFp3sdzrZ9SDFwDKYAUR_TjDxE,191
+jvserve/cli.py,sha256=NJD4ehtKnhOvsz-vrFh9lz3P4bnxqz-uqTr8QItljZc,8897
+jvserve/lib/__init__.py,sha256=cnzfSHLoTWG9Ygut2nOpDys5aPlQz-m0BSkB-nd7OMs,31
+jvserve/lib/agent_interface.py,sha256=d2trRXgLjUzciGSRwYD2Rl-TPnyJVpUKrgG1iU7CGyw,37768
+jvserve/lib/agent_pulse.py,sha256=6hBF6KQYr6Z9Mi_yoWKGfdnW7gg84kK20Slu-bLR_m8,2067
+jvserve/lib/file_interface.py,sha256=sqwTmBnZsVFQUGt7mE1EWA-jHnZlRtBAFeb4Rb_QgQ8,6079
+jvserve/lib/jvlogger.py,sha256=RNiB9PHuBzTvNIQWhxoDgrDlNYA0PYm1SVpvzlqu8mE,4180
+jvserve-2.0.15.dist-info/licenses/LICENSE,sha256=xx0jnfkXJvxRnG63LTGOxlggYnIysveWIZ6H3PNdCrQ,11357
+jvserve-2.0.15.dist-info/METADATA,sha256=eXjQb1zag7Si-czz5V4wX60-6wr9E2eyz3yIETUF9i0,4791
+jvserve-2.0.15.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
+jvserve-2.0.15.dist-info/entry_points.txt,sha256=HYyg1QXoLs0JRb004L300VeLOZyDLY27ynD1tnTnEN4,35
+jvserve-2.0.15.dist-info/top_level.txt,sha256=afoCXZv-zXNBuhVIvfJGjafXKEiJl_ooy4BtgQwAG4Q,8
+jvserve-2.0.15.dist-info/RECORD,,

jvserve-2.0.13.dist-info/RECORD

@@ -1,13 +0,0 @@
-jvserve/__init__.py,sha256=AHR-iejuKB2C8u25HZ1ccXlh6tCaB3MuKVTJz-LZzig,191
-jvserve/cli.py,sha256=NJD4ehtKnhOvsz-vrFh9lz3P4bnxqz-uqTr8QItljZc,8897
-jvserve/lib/__init__.py,sha256=cnzfSHLoTWG9Ygut2nOpDys5aPlQz-m0BSkB-nd7OMs,31
-jvserve/lib/agent_interface.py,sha256=4SHqvySxu08dK2cPoe2TjMKlm11VqM0qDalOKp-tma4,32347
-jvserve/lib/agent_pulse.py,sha256=6hBF6KQYr6Z9Mi_yoWKGfdnW7gg84kK20Slu-bLR_m8,2067
-jvserve/lib/file_interface.py,sha256=sqwTmBnZsVFQUGt7mE1EWA-jHnZlRtBAFeb4Rb_QgQ8,6079
-jvserve/lib/jvlogger.py,sha256=RNiB9PHuBzTvNIQWhxoDgrDlNYA0PYm1SVpvzlqu8mE,4180
-jvserve-2.0.13.dist-info/licenses/LICENSE,sha256=xx0jnfkXJvxRnG63LTGOxlggYnIysveWIZ6H3PNdCrQ,11357
-jvserve-2.0.13.dist-info/METADATA,sha256=8gyJ1EnRbjZDZnOU3F-Y4lq9loXHIGLNCXn3YpPiUzg,4791
-jvserve-2.0.13.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
-jvserve-2.0.13.dist-info/entry_points.txt,sha256=HYyg1QXoLs0JRb004L300VeLOZyDLY27ynD1tnTnEN4,35
-jvserve-2.0.13.dist-info/top_level.txt,sha256=afoCXZv-zXNBuhVIvfJGjafXKEiJl_ooy4BtgQwAG4Q,8
-jvserve-2.0.13.dist-info/RECORD,,