jvserve 2.0.15__tar.gz → 2.1.1__tar.gz

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: jvserve
-Version: 2.0.15
+Version: 2.1.1
 Summary: FastAPI webserver for loading and interaction with JIVAS agents.
 Home-page: https://github.com/TrueSelph/jvserve
 Author: TrueSelph Inc.
@@ -9,7 +9,8 @@ Keywords: jivas
 Requires-Python: >=3.12.0
 Description-Content-Type: text/markdown
 License-File: LICENSE
-Requires-Dist: jac-cloud==0.1.20
+Requires-Dist: jac-cloud
+Requires-Dist: jaclang==0.8.4
 Requires-Dist: pyaml>=25.1.0
 Requires-Dist: requests>=2.32.3
 Requires-Dist: aiohttp>=3.10.10
@@ -80,7 +81,7 @@ jac jvfileserve ./static
 ### Supported Arguments
 
 - **filename**: Path to your JAC file.
-- **host**: Host address to bind the server (default: `0.0.0.0`).
+- **host**: Host address to bind the server (default: `localhost`).
 - **port**: Port number to bind the server (default: `8000`).
 - **loglevel**: Logging level (default: `INFO`).
 - **workers**: Number of worker processes (optional).

{jvserve-2.0.15 → jvserve-2.1.1}/README.md

@@ -45,7 +45,7 @@ jac jvfileserve ./static
 ### Supported Arguments
 
 - **filename**: Path to your JAC file.
-- **host**: Host address to bind the server (default: `0.0.0.0`).
+- **host**: Host address to bind the server (default: `localhost`).
 - **port**: Port number to bind the server (default: `8000`).
 - **loglevel**: Logging level (default: `INFO`).
 - **workers**: Number of worker processes (optional).

{jvserve-2.0.15 → jvserve-2.1.1}/jvserve/__init__.py

@@ -4,5 +4,7 @@ jvserve package initialization.
 This package provides the webserver for loading and interacting with JIVAS agents.
 """
 
-__version__ = "2.0.15"
-__supported__jivas__versions__ = ["2.0.0"]
+from importlib.metadata import version
+
+__version__ = version("jvserve")
+__supported__jivas__versions__ = [__version__]

jvserve-2.1.1/jvserve/cli.py

@@ -0,0 +1,256 @@
+"""Module for registering CLI plugins for jaseci."""
+
+import asyncio
+import logging
+import os
+from concurrent.futures import ThreadPoolExecutor
+from contextlib import asynccontextmanager
+from pickle import load
+from typing import AsyncIterator, Optional
+
+import aiohttp
+import pymongo
+from bson import ObjectId
+from dotenv import load_dotenv
+from fastapi import FastAPI, HTTPException, Response
+from fastapi.middleware.cors import CORSMiddleware
+from fastapi.responses import FileResponse, StreamingResponse
+from jac_cloud.core.context import JaseciContext
+from jac_cloud.jaseci.main import FastAPI as JaseciFastAPI  # type: ignore
+from jac_cloud.plugin.jaseci import NodeAnchor
+from jaclang import JacMachine as Jac
+from jaclang.cli.cmdreg import cmd_registry
+from jaclang.runtimelib.machine import hookimpl
+from watchfiles import Change, run_process
+
+from jvserve.lib.agent_interface import AgentInterface
+from jvserve.lib.file_interface import (
+    DEFAULT_FILES_ROOT,
+    FILE_INTERFACE,
+    file_interface,
+)
+from jvserve.lib.jvlogger import JVLogger
+
+# quiet the jac_cloud logger down to errors only
+# jac cloud dumps payload details to console which makes it hard to debug in JIVAS
+os.environ["LOGGER_LEVEL"] = "ERROR"
+load_dotenv(".env")
+# Set up logging
+JVLogger.setup_logging(level="INFO")
+logger = logging.getLogger(__name__)
+
+# Global for MongoDB collection with thread-safe initialization
+url_proxy_collection = None
+collection_init_lock = asyncio.Lock()
+
+
+async def get_url_proxy_collection() -> pymongo.collection.Collection:
+    """Thread-safe initialization of MongoDB collection"""
+    global url_proxy_collection
+    if url_proxy_collection is None:
+        async with collection_init_lock:
+            if url_proxy_collection is None:  # Double-check locking
+                loop = asyncio.get_running_loop()
+                with ThreadPoolExecutor() as pool:
+                    url_proxy_collection = await loop.run_in_executor(
+                        pool,
+                        lambda: NodeAnchor.Collection.get_collection("url_proxies"),
+                    )
+    return url_proxy_collection
+
+
+async def serve_proxied_file(
+    file_path: str,
+) -> FileResponse | StreamingResponse | Response:
+    """Serve a proxied file from a remote or local URL (async version)"""
+    if FILE_INTERFACE == "local":
+        root_path = os.environ.get("JIVAS_FILES_ROOT_PATH", DEFAULT_FILES_ROOT)
+        full_path = os.path.join(root_path, file_path)
+        if not os.path.exists(full_path):
+            raise HTTPException(status_code=404, detail="File not found")
+        return FileResponse(full_path)
+
+    file_url = file_interface.get_file_url(file_path)
+
+    # Security check to prevent recursive calls
+    if file_url and ("localhost" in file_url or "127.0.0.1" in file_url):
+        raise HTTPException(
+            status_code=500, detail="Environment misconfiguration detected"
+        )
+
+    if not file_url:
+        raise HTTPException(status_code=404, detail="File not found")
+
+    try:
+        async with aiohttp.ClientSession() as session:
+            async with session.get(file_url) as response:
+                response.raise_for_status()
+
+                return StreamingResponse(
+                    response.content.iter_chunked(8192),
+                    media_type=response.headers.get(
+                        "Content-Type", "application/octet-stream"
+                    ),
+                )
+    except aiohttp.ClientError as e:
+        raise HTTPException(status_code=502, detail=f"File fetch error: {str(e)}")
+
+
+def run_jivas(filename: str, host: str = "localhost", port: int = 8000) -> None:
+    """Starts JIVAS server with integrated file services"""
+
+    # Create agent interface instance with configuration
+    agent_interface = AgentInterface.get_instance(host=host, port=port)
+
+    base, mod = os.path.split(filename)
+    base = base if base else "./"
+    mod = mod[:-4]
+
+    JaseciFastAPI.enable()
+
+    ctx = JaseciContext.create(None)
+    if filename.endswith(".jac"):
+        Jac.jac_import(target=mod, base_path=base, override_name="__main__")
+    elif filename.endswith(".jir"):
+        with open(filename, "rb") as f:
+            Jac.attach_program(load(f))
+            Jac.jac_import(target=mod, base_path=base, override_name="__main__")
+    else:
+        raise ValueError("Not a valid file!\nOnly supports `.jac` and `.jir`")
+
+    # Define post-startup function to run AFTER server is ready
+    async def post_startup() -> None:
+        """Wait for server to be ready before initializing agents"""
+        health_url = f"http://{host}:{port}/healthz"
+        max_retries = 10
+        retry_delay = 1.0
+
+        for attempt in range(max_retries):
+            try:
+                async with aiohttp.ClientSession() as session:
+                    async with session.get(health_url, timeout=1) as response:
+                        if response.status == 200:
+                            logger.info("Server is ready, initializing agents...")
+                            await agent_interface.init_agents()
+                            return
+            except (aiohttp.ClientConnectorError, asyncio.TimeoutError) as e:
+                logger.warning(
+                    f"Server not ready yet (attempt {attempt + 1} / {max_retries}): {e}"
+                )
+                await asyncio.sleep(retry_delay)
+                retry_delay *= 1.5  # Exponential backoff
+
+        logger.error(
+            "Server did not become ready in time. Agent initialization skipped."
+        )
+
+    # set up lifespan events
+    async def on_startup() -> None:
+        logger.info("JIVAS is starting up...")
+        # Start initialization in background without blocking
+        asyncio.create_task(post_startup())
+
+    async def on_shutdown() -> None:
+        logger.info("JIVAS is shutting down...")
+
+    app = JaseciFastAPI.get()
+    app_lifespan = app.router.lifespan_context
+
+    @asynccontextmanager
+    async def lifespan_wrapper(app: FastAPI) -> AsyncIterator[Optional[str]]:
+        await on_startup()
+        async with app_lifespan(app) as maybe_state:
+            yield maybe_state
+        await on_shutdown()
+
+    app.router.lifespan_context = lifespan_wrapper
+
+    # Add CORS middleware to main app
+    app.add_middleware(
+        CORSMiddleware,
+        allow_origins=["*"],
+        allow_credentials=True,
+        allow_methods=["*"],
+        allow_headers=["*"],
+    )
+
+    # Ensure the local file directory exists if that's the interface
+    if FILE_INTERFACE == "local":
+        directory = os.environ.get("JIVAS_FILES_ROOT_PATH", DEFAULT_FILES_ROOT)
+        if not os.path.exists(directory):
+            os.makedirs(directory, exist_ok=True)
+
+    # Setup file serving endpoint for both local and S3
+    @app.get("/files/{file_path:path}", response_model=None)
+    async def serve_file(
+        file_path: str,
+    ) -> FileResponse | StreamingResponse | Response:
+        # The serve_proxied_file function already handles both local and S3 cases
+        return await serve_proxied_file(file_path)
+
+    # Setup URL proxy endpoint
+    @app.get("/f/{file_id:path}", response_model=None)
+    async def get_proxied_file(
+        file_id: str,
+    ) -> FileResponse | StreamingResponse | Response:
+        params = file_id.split("/")
+        object_id = params[0]
+
+        try:
+            # Get MongoDB collection (thread-safe initialization)
+            collection = await get_url_proxy_collection()
+
+            # Run blocking MongoDB operation in thread pool
+            loop = asyncio.get_running_loop()
+            file_details = await loop.run_in_executor(
+                None, lambda: collection.find_one({"_id": ObjectId(object_id)})
+            )
+
+            descriptor_path = os.environ.get("JIVAS_DESCRIPTOR_ROOT_PATH")
+
+            if file_details:
+                if descriptor_path and descriptor_path in file_details["path"]:
+                    return Response(status_code=403)
+                return await serve_proxied_file(file_details["path"])
+
+            raise HTTPException(status_code=404, detail="File not found")
+        except Exception as e:
+            logger.error(f"Proxy error: {str(e)}")
+            raise HTTPException(status_code=500, detail="Internal server error")
+
+    ctx.close()
+    # Run the app
+    JaseciFastAPI.start(host=host, port=port)
+
+
+def log_reload(changes: set[tuple[Change, str]]) -> None:
+    """Log changes."""
+    num_of_changes = len(changes)
+    logger.warning(
+        f'Detected {num_of_changes} change{"s" if num_of_changes > 1 else ""}'
+    )
+    for change in changes:
+        logger.warning(f"{change[1]} ({change[0].name})")
+    logger.warning("Reloading ...")
+
+
+class JacCmd:
+    """Jac CLI."""
+
+    @staticmethod
+    @hookimpl
+    def create_cmd() -> None:
+        """Create Jac CLI cmds."""
+
+        @cmd_registry.register
+        def jvserve(filename: str, host: str = "localhost", port: int = 8000) -> None:
+            """Launch unified JIVAS server with file services"""
+            watchdir = os.path.join(
+                os.path.abspath(os.path.dirname(filename)), "actions", ""
+            )
+            run_process(
+                watchdir,
+                target=run_jivas,
+                args=(filename, host, port),
+                callback=log_reload,
+            )

jvserve-2.1.1/jvserve/lib/agent_interface.py

@@ -0,0 +1,97 @@
+"""Agent Interface class and methods for interaction with Jivas."""
+
+import logging
+import os
+import traceback
+from typing import Any
+
+import requests
+
+from jvserve.lib.jac_interface import JacInterface
+
+
+class AgentInterface:
+    """Agent Interface for Jivas with proper concurrency handling."""
+
+    _instance = None
+    logger = logging.getLogger(__name__)
+
+    def __init__(self, host: str = "localhost", port: int = 8000) -> None:
+        """Initialize the AgentInterface with JacInterface."""
+        self._jac = JacInterface(host, port)
+
+    @classmethod
+    def get_instance(
+        cls, host: str = "localhost", port: int = 8000
+    ) -> "AgentInterface":
+        """Get a singleton instance of AgentInterface."""
+        if cls._instance is None:
+            env_host = os.environ.get("JIVAS_HOST", "localhost")
+            env_port = int(os.environ.get("JIVAS_PORT", "8000"))
+            host = host or env_host
+            port = port or env_port
+            cls._instance = cls(host, port)
+        return cls._instance
+
+    async def init_agents(self) -> None:
+        """Initialize agents - async compatible"""
+        try:
+            if not await self._jac.spawn_walker_async(
+                walker_name="init_agents",
+                module_name="jivas.agent.core.init_agents",
+                attributes={"reporting": False},
+            ):
+                self.logger.error("Agent initialization failed")
+        except Exception as e:
+            self._jac.reset()
+            self.logger.error(f"Init error: {e}\n{traceback.format_exc()}")
+
+    def api_pulse(self, action_label: str, agent_id: str) -> dict:
+        """Synchronous pulse API call"""
+        if not self._jac.is_valid():
+            self.logger.warning("Invalid API state for pulse")
+            return {}
+
+        # Clean parameters
+        action_label = action_label.replace("action_label=", "")
+        agent_id = agent_id.replace("agent_id=", "")
+
+        endpoint = f"http://{self._jac.host}:{self._jac.port}/walker/do_pulse"
+        headers = {"Authorization": f"Bearer {self._jac.token}"}
+        payload = {"action_label": action_label, "agent_id": agent_id}
+
+        try:
+            response = requests.post(
+                endpoint, json=payload, headers=headers, timeout=10
+            )
+            if response.status_code == 200:
+                return response.json().get("reports", {})
+            if response.status_code == 401:
+                self._jac.reset()
+        except Exception as e:
+            self._jac.reset()
+            self.logger.error(f"Pulse error: {e}\n{traceback.format_exc()}")
+
+        return {}
+
+    async def _finalize_interaction(
+        self, interaction_node: Any, full_text: str, total_tokens: int
+    ) -> None:
+        """Finalize interaction in background"""
+        try:
+            interaction_node.set_text_message(message=full_text)
+            interaction_node.add_tokens(total_tokens)
+
+            await self._jac.spawn_walker_async(
+                walker_name="update_interaction",
+                module_name="jivas.agent.memory.update_interaction",
+                attributes={"interaction_data": interaction_node.export()},
+            )
+        except Exception as e:
+            self.logger.error(f"Finalize error: {e}")
+
+
+# Module-level functions
+def do_pulse(action_label: str, agent_id: str) -> dict:
+    """Execute pulse action synchronously"""
+    return AgentInterface.get_instance().api_pulse(action_label, agent_id)

{jvserve-2.0.15 → jvserve-2.1.1}/jvserve/lib/file_interface.py

@@ -78,7 +78,7 @@ class LocalFileInterface(FileInterface):
         """Get URL for accessing local file via HTTP."""
         file_path = os.path.join(self.__root_dir, filename)
         if os.path.exists(file_path):
-            return f"{os.environ.get('JIVAS_FILES_URL', 'http://localhost:9000/files')}/{filename}"
+            return f"{os.environ.get('JIVAS_FILES_URL', 'http://localhost:8000/files')}/{filename}"
         return None
 
 

jvserve-2.1.1/jvserve/lib/jac_interface.py

@@ -0,0 +1,222 @@
+"""JacInterface: A connection and context state provider for Jac Runtime."""
+
+import asyncio
+import logging
+import os
+import threading
+import time
+import traceback
+from typing import Optional, Tuple
+
+import requests
+from fastapi import Request
+from jac_cloud.core.archetype import (  # type: ignore
+    NodeAnchor,
+    WalkerArchetype,
+)
+from jac_cloud.core.context import (
+    JASECI_CONTEXT,
+    JaseciContext,
+)
+from jac_cloud.plugin.jaseci import JacPlugin
+from jaclang.runtimelib.machine import JacMachine
+
+
+class JacInterface:
+    """Thread-safe connection and context state provider for Jac Runtime with auto-authentication."""
+
+    def __init__(self, host: str = "localhost", port: int = 8000) -> None:
+        """Initialize JacInterface with host and port."""
+        self.host = host
+        self.port = port
+        self.root_id = ""
+        self.token = ""
+        self.expiration = 0.0
+        self._lock = threading.RLock()  # Thread-safe lock
+        self.logger = logging.getLogger(__name__)
+
+    def update(self, root_id: str, token: str, expiration: float) -> None:
+        """Thread-safe state update"""
+        with self._lock:
+            self.root_id = root_id
+            self.token = token
+            self.expiration = expiration
+
+    def reset(self) -> None:
+        """Thread-safe state reset"""
+        with self._lock:
+            self.root_id = ""
+            self.token = ""
+            self.expiration = 0.0
+
+    def is_valid(self) -> bool:
+        """Thread-safe validity check"""
+        with self._lock:
+            return bool(
+                self.token and self.expiration and self.expiration > time.time()
+            )
+
+    def get_state(self) -> Tuple[str, str, Optional[float]]:
+        """Get current state with auto-authentication"""
+        if not self.is_valid():
+            self._authenticate()
+        with self._lock:
+            return (self.root_id, self.token, self.expiration)
+
+    def get_context(self, request: Request | None = None) -> Optional[JaseciContext]:
+        """Get Jaseci context with proper thread safety."""
+
+        state = self.get_state()
+        if not state or not self.is_valid():
+            self.logger.error("Failed to get valid state for Jaseci context")
+            return None
+
+        try:
+            root_id = state[0]
+            entry_node = NodeAnchor.ref(f"n:root:{root_id}")  # type: ignore
+            if not entry_node:
+                self.logger.error("Failed to resolve entry node from root_id")
+                return None
+
+            ctx = JaseciContext.create(request, entry_node)
+            if not ctx:
+                self.logger.error("Failed to create JaseciContext with entry node")
+                return None
+
+            ctx.system_root = entry_node
+            ctx.root_state = entry_node
+
+            # Clean up any existing context before setting new one
+            existing_ctx = JASECI_CONTEXT.get(None)
+            if existing_ctx:
+                try:
+                    existing_ctx.close()
+                except Exception as e:
+                    self.logger.warning(f"Error while closing existing context: {e}")
+
+            JASECI_CONTEXT.set(ctx)
+            return ctx
+
+        except Exception as e:
+            self.logger.error(
+                f"Failed to create JaseciContext: {e}\n{traceback.format_exc()}"
+            )
+            return None
+
+    def spawn_walker(
+        self,
+        walker_name: str | None,
+        module_name: str,
+        attributes: dict = {},  # noqa: B006
+        request: Request | None = None,  # noqa: B006
+    ) -> Optional[WalkerArchetype]:
+        """Spawn walker with proper context handling and thread safety"""
+
+        if not all([walker_name, module_name]):
+            self.logger.error("Missing required parameters for spawning walker")
+            return None
+
+        ctx = self.get_context(request)
+        if not ctx:
+            return None
+
+        try:
+            if module_name not in JacMachine.list_modules():
+                self.logger.error(f"Module {module_name} not loaded")
+                return None
+
+            entry_node = ctx.entry_node.archetype
+
+            return JacPlugin.spawn(
+                JacMachine.spawn_walker(walker_name, attributes, module_name),
+                entry_node,
+            )
+        except Exception as e:
+            self.logger.error(f"Error spawning walker: {e}\n{traceback.format_exc()}")
+            return None
+        finally:
+            if ctx:
+                ctx.close()
+                if JASECI_CONTEXT.get(None) == ctx:
+                    JASECI_CONTEXT.set(None)
+
+    def _authenticate(self) -> None:
+        """Thread-safe authentication with retry logic and improved error handling"""
+        user = os.environ.get("JIVAS_USER")
+        password = os.environ.get("JIVAS_PASSWORD")
+        if not user or not password:
+            self.logger.error("Missing JIVAS_USER or JIVAS_PASSWORD")
+            return
+
+        login_url = f"http://{self.host}:{self.port}/user/login"
+        register_url = f"http://{self.host}:{self.port}/user/register"
+
+        with self._lock:
+            try:
+                # Try login first
+                response = requests.post(
+                    login_url, json={"email": user, "password": password}, timeout=15
+                )
+                self.logger.info(f"Login response status: {response.status_code}")
+                if response.status_code == 200:
+                    self._process_auth_response(response.json())
+                    return
+
+                # Register if login fails
+                reg_response = requests.post(
+                    register_url, json={"email": user, "password": password}, timeout=15
+                )
+                self.logger.info(
+                    f"Register response status: {reg_response.status_code}"
+                )
+                if reg_response.status_code == 201:
+                    # Retry login after registration
+                    login_response = requests.post(
+                        login_url,
+                        json={"email": user, "password": password},
+                        timeout=15,
+                    )
+                    self.logger.info(
+                        f"Retry login response status: {login_response.status_code}"
+                    )
+                    if login_response.status_code == 200:
+                        self._process_auth_response(login_response.json())
+            except requests.exceptions.RequestException as e:
+                self.logger.error(f"Network error during authentication: {e}")
+            except Exception as e:
+                self.logger.error(
+                    f"Authentication failed: {e}\n{traceback.format_exc()}"
+                )
+                self.reset()
+
+    def _process_auth_response(self, response_data: dict) -> None:
+        """Process authentication response and update state"""
+        user_data = response_data.get("user", {})
+        root_id = user_data.get("root_id", "")
+        token = response_data.get("token", "")
+        expiration = user_data.get("expiration")
+
+        if not all([root_id, token, expiration]):
+            self.logger.error("Invalid authentication response")
+            return
+
+        self.update(root_id, token, expiration)
+
+    # Async versions of methods
+    async def _authenticate_async(self) -> None:
+        """Asynchronous wrapper for authentication"""
+        loop = asyncio.get_running_loop()
+        await loop.run_in_executor(None, self._authenticate)
+
+    async def spawn_walker_async(
+        self,
+        walker_name: str,
+        module_name: str,
+        attributes: dict,
+        request: Request | None = None,
+    ) -> Optional[WalkerArchetype]:
+        """Asynchronous wrapper for walker spawning"""
+        loop = asyncio.get_running_loop()
+        return await loop.run_in_executor(
+            None, self.spawn_walker, walker_name, module_name, attributes, request
+        )

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: jvserve
-Version: 2.0.15
+Version: 2.1.1
 Summary: FastAPI webserver for loading and interaction with JIVAS agents.
 Home-page: https://github.com/TrueSelph/jvserve
 Author: TrueSelph Inc.
@@ -9,7 +9,8 @@ Keywords: jivas
 Requires-Python: >=3.12.0
 Description-Content-Type: text/markdown
 License-File: LICENSE
-Requires-Dist: jac-cloud==0.1.20
+Requires-Dist: jac-cloud
+Requires-Dist: jaclang==0.8.4
 Requires-Dist: pyaml>=25.1.0
 Requires-Dist: requests>=2.32.3
 Requires-Dist: aiohttp>=3.10.10
@@ -80,7 +81,7 @@ jac jvfileserve ./static
 ### Supported Arguments
 
 - **filename**: Path to your JAC file.
-- **host**: Host address to bind the server (default: `0.0.0.0`).
+- **host**: Host address to bind the server (default: `localhost`).
 - **port**: Port number to bind the server (default: `8000`).
 - **loglevel**: Logging level (default: `INFO`).
 - **workers**: Number of worker processes (optional).

{jvserve-2.0.15 → jvserve-2.1.1}/jvserve.egg-info/SOURCES.txt

@@ -11,8 +11,8 @@ jvserve.egg-info/requires.txt
 jvserve.egg-info/top_level.txt
 jvserve/lib/__init__.py
 jvserve/lib/agent_interface.py
-jvserve/lib/agent_pulse.py
 jvserve/lib/file_interface.py
+jvserve/lib/jac_interface.py
 jvserve/lib/jvlogger.py
 tests/test_file_interface.py
 tests/test_jvlogger.py

{jvserve-2.0.15 → jvserve-2.1.1}/jvserve.egg-info/requires.txt

@@ -1,4 +1,5 @@
-jac-cloud==0.1.20
+jac-cloud
+jaclang==0.8.4
 pyaml>=25.1.0
 requests>=2.32.3
 aiohttp>=3.10.10