jvserve 2.0.12__tar.gz → 2.0.15__tar.gz

{jvserve-2.0.12 → jvserve-2.0.15}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: jvserve
-Version: 2.0.12
+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.12 → jvserve-2.0.15}/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.12"
+__version__ = "2.0.15"
 __supported__jivas__versions__ = ["2.0.0"]

{jvserve-2.0.12 → jvserve-2.0.15}/jvserve/cli.py

@@ -7,14 +7,13 @@ from contextlib import asynccontextmanager
 from typing import AsyncIterator, Optional
 
 from dotenv import load_dotenv
-from fastapi.responses import FileResponse, StreamingResponse
+from fastapi.responses import FileResponse, Response, StreamingResponse
 from jac_cloud.jaseci.security import authenticator
 from jac_cloud.plugin.jaseci import NodeAnchor
 from jaclang.cli.cmdreg import cmd_registry
 from jaclang.plugin.default import hookimpl
 from jaclang.runtimelib.context import ExecutionContext
 from jaclang.runtimelib.machine import JacMachine
-from requests import Response
 from uvicorn import run as _run
 
 from jvserve.lib.agent_interface import AgentInterface
@@ -216,8 +215,7 @@ class JacCmd:
         ) -> None:
             """Launch the file proxy server for remote files."""
             # load FastAPI
-            from bson import ObjectId
-            from fastapi import FastAPI, HTTPException
+            from fastapi import FastAPI
             from fastapi.middleware.cors import CORSMiddleware
 
             # Setup custom routes
@@ -238,21 +236,32 @@ class JacCmd:
                 @app.get("/files/{file_path:path}", response_model=None)
                 async def serve_file(
                     file_path: str,
-                ) -> Response:
+                ) -> FileResponse | StreamingResponse | Response:
+                    descriptor_path = os.environ["JIVAS_DESCRIPTOR_ROOT_PATH"]
+                    if descriptor_path and descriptor_path in file_path:
+                        return Response(status_code=403)
+
                     return serve_proxied_file(file_path)
 
             @app.get("/f/{file_id:path}", response_model=None)
             async def get_proxied_file(
                 file_id: str,
-            ) -> Response:
+            ) -> FileResponse | StreamingResponse | Response:
+                from bson import ObjectId
+                from fastapi import HTTPException
+
                 params = file_id.split("/")
                 object_id = params[0]
 
                 # mongo db collection
                 collection = NodeAnchor.Collection.get_collection("url_proxies")
                 file_details = collection.find_one({"_id": ObjectId(object_id)})
+                descriptor_path = os.environ["JIVAS_DESCRIPTOR_ROOT_PATH"]
 
                 if file_details:
+                    if descriptor_path and descriptor_path in file_details["path"]:
+                        return Response(status_code=403)
+
                     return serve_proxied_file(file_details["path"])
 
                 raise HTTPException(status_code=404, detail="File not found")

{jvserve-2.0.12 → jvserve-2.0.15}/jvserve/lib/agent_interface.py

@@ -1,5 +1,6 @@
 """Agent Interface class and methods for interaction with Jivas."""
 
+import asyncio
 import json
 import logging
 import os
@@ -158,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"},
+                )
 
-            # add agent id as a standard
+            # 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"},
+                )
+
+            # 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."""
@@ -243,7 +378,7 @@ class AgentInterface:
         streaming: Optional[bool] = None
 
     @staticmethod
-    def interact(payload: InteractPayload) -> dict:
+    def interact(payload: InteractPayload, request: Request) -> dict:
         """Interact with the agent."""
         response = None
         ctx = AgentInterface.load_context()
@@ -291,7 +426,7 @@ class AgentInterface:
                     interaction_node = response.interaction_node
 
                     async def generate(
-                        generator: Iterator,
+                        generator: Iterator, request: Request
                     ) -> AsyncGenerator[str, None]:
                         """
                         Asynchronously yield data chunks from a response generator in Server-Sent Events (SSE) format.
@@ -304,11 +439,11 @@ class AgentInterface:
                         """
                         full_text = ""
                         total_tokens = 0
+
                         try:
                             for chunk in generator:
                                 full_text += chunk.content
                                 total_tokens += 1  # each chunk is a token, let's tally
-                                await sleep(0.025)
                                 yield (
                                     "data: "
                                     + json.dumps(
@@ -324,6 +459,7 @@ class AgentInterface:
                                     )
                                     + "\n\n"
                                 )
+                                await sleep(0.025)
                             # Update the interaction node with the fully generated text
                             actx = await AgentInterface.load_context_async()
                             try:
@@ -336,7 +472,7 @@ class AgentInterface:
                                         attributes={
                                             "interaction_data": interaction_node.export(),
                                         },
-                                        module_name="jivas.agent.action.update_interaction",
+                                        module_name="jivas.agent.memory.update_interaction",
                                     ),
                                 )
                             finally:
@@ -347,9 +483,30 @@ class AgentInterface:
                             AgentInterface.LOGGER.error(
                                 f"Exception in streaming generator: {e}, {traceback.format_exc()}"
                             )
+                        except asyncio.CancelledError:
+                            AgentInterface.LOGGER.error(
+                                "Client disconnected. Aborting stream."
+                            )
+                            actx = await AgentInterface.load_context_async()
+                            try:
+                                interaction_node.set_text_message(message=full_text)
+                                interaction_node.add_tokens(total_tokens)
+                                _Jac.spawn_call(
+                                    NodeAnchor.ref(interaction_node.id).architype,
+                                    AgentInterface.spawn_walker(
+                                        walker_name="update_interaction",
+                                        attributes={
+                                            "interaction_data": interaction_node.export(),
+                                        },
+                                        module_name="jivas.agent.memory.update_interaction",
+                                    ),
+                                )
+                            finally:
+                                if actx:
+                                    actx.close()
 
                     return StreamingResponse(
-                        generate(response.generator),
+                        generate(response.generator, request),
                         media_type="text/event-stream",
                     )
 

{jvserve-2.0.12 → jvserve-2.0.15}/jvserve.egg-info/PKG-INFO

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