bump: versions (#38)

* chore: better server extension

* bump: versions

Author: echarles

README.md

@@ -59,7 +59,7 @@ We ask you to take additional actions to overcome limitations and bugs of the py
 
 ```bash
 pip uninstall -y pycrdt datalayer_pycrdt
-pip install datalayer_pycrdt==0.12.15
+pip install datalayer_pycrdt==0.12.17
 ```
 
 ## Use from the CLI

docs/_tmp/fine-tuned/_category_.yaml

@@ -4,4 +4,4 @@
 
 """Jupyter AI Agents."""
 
-__version__ = "0.10.2"
+__version__ = "0.11.1"

docs/_tmp/fine-tuned/index.mdx

@@ -1,4 +1,3 @@
 # Copyright (c) 2023-2024 Datalayer, Inc.
 #
 # Datalayer License
-

docs/_tmp/llama3/_category_.yaml

@@ -2,47 +2,42 @@
 #
 # BSD 3-Clause License
 
-# Copyright (c) 2021-2024 Datalayer, Inc.
-#
-# Datalayer License
-
 from __future__ import annotations
 
 import json
 import logging
 
-from pydantic import BaseModel
-from typing import Optional
-
 from concurrent import futures
 from concurrent.futures import as_completed
 
 from anyio import create_task_group, sleep
 from anyio.from_thread import start_blocking_portal
 
-from jupyter_kernel_client import KernelClient
-
 from jupyter_server.utils import url_path_join
 from jupyter_server.base.handlers import APIHandler
 
-from jupyter_ai_agents import __version__
+from jupyter_kernel_client import KernelClient
+
+from jupyter_ai_agents.handlers.agents.manager import AIAgentsManager
 from jupyter_ai_agents.agents.prompt import PromptAgent
-from jupyter_ai_agents.handlers.agents.agents import AIAgentsManager
+from jupyter_ai_agents.models import AgentRequestModel
 from jupyter_ai_agents.utils import http_to_ws
+from jupyter_ai_agents import __version__
 
 
 logger = logging.getLogger(__name__)
 
+
 EXECUTOR = futures.ThreadPoolExecutor(8)
 
-MANAGER = None
+AI_AGENTS_MANAGER: AIAgentsManager | None = None
 
-ROOMS = {}
+# COLLABORATION_ROOMS = {}
 
 
 def prompt_ai_agent(room_id, jupyter_ingress, jupyter_token, kernel_id):
     async def long_running_prompt():
-        global MANAGER
+        global AI_AGENTS_MANAGER
         room_ws_url = http_to_ws(url_path_join(jupyter_ingress, "/api/collaboration/room", room_id))
         logger.info("AI Agent will connect to room [%s]…", room_ws_url)
         has_runtime = jupyter_ingress and jupyter_token and kernel_id
@@ -56,55 +51,46 @@ async def long_running_prompt():
             log=logger,
         )
         logger.info("Starting AI Agent for room [%s]…", room_id)
-        async def sometask() -> None:
-            print('Task running')
+        async def prompt_task() -> None:
+            logger.info('Starting Prompt Agent.')
             await prompt_agent.start()
             if prompt_agent.runtime_client is not None:
                 prompt_agent.runtime_client.start()
-            print('Task finished')
+            logger.info('Prompt Agent is started.')
         async with create_task_group() as tg:
-            tg.start_soon(sometask)
-        await sleep(20)
-#        await MANAGER.track_agent(room_id, prompt_agent)
-        print('Task running...')
-        return 'Task return value'
+            tg.start_soon(prompt_task)
+        AI_AGENTS_MANAGER.register_ai_agent(room_id, prompt_agent)
+        # Sleep forever to keep the ai agent alive.
+        # TODO Replace with AI_AGENTS_MANAGER
+        while True:
+           await sleep(10)
+#        await AI_AGENTS_MANAGER.track_agent(room_id, prompt_agent)
+        return 'Prompt task is finished.'
     with start_blocking_portal() as portal:
         futures = [portal.start_task_soon(long_running_prompt)]
         for future in as_completed(futures):
-            print(future.result())
-
-
-class RuntimeModel(BaseModel):
-    ingress: Optional[str] = None
-    token: Optional[str] = None
-    kernel_id: Optional[str] = None
-    jupyter_pod_name: Optional[str] = None
-
-
-class AgentRequestModel(BaseModel):
-    room_id: Optional[str] = None
-    runtime: Optional[RuntimeModel] = None
+            logger.info("Future is completed with result [%s]", future.result())
 
 
-class AIAgentHandler(APIHandler):
+class AIAgentsInstanceHandler(APIHandler):
 
 #    @web.authenticated
     async def get(self, matched_part=None, *args, **kwargs):
-        global MANAGER
-        if MANAGER is None:
-            MANAGER = AIAgentsManager()
+        global AI_AGENTS_MANAGER
+        if AI_AGENTS_MANAGER is None:
+            AI_AGENTS_MANAGER = AIAgentsManager()
         self.write({
             "success": True,
             "matched_part": matched_part,
         })
 
 #    @web.authenticated
     async def post(self, matched_part=None, *args, **kwargs):
-        global MANAGER
-        if MANAGER is None:
-            MANAGER = AIAgentsManager()
+        global AI_AGENTS_MANAGER
+        if AI_AGENTS_MANAGER is None:
+            AI_AGENTS_MANAGER = AIAgentsManager()
         body_data = json.loads(self.request.body)
-        print(body_data)
+        logger.info("Body data", body_data)
         self.write({
             "success": True,
             "matched_part": matched_part,
@@ -115,26 +101,26 @@ class AIAgentsHandler(APIHandler):
 
 #    @web.authenticated
     async def get(self, *args, **kwargs):
-        global MANAGER
-        if MANAGER is None:
-            MANAGER = AIAgentsManager()
+        global AI_AGENTS_MANAGER
+        if AI_AGENTS_MANAGER is None:
+            AI_AGENTS_MANAGER = AIAgentsManager()
         self.write({
             "success": True,
         })
 
 #    @web.authenticated
     async def post(self, *args, **kwargs):
         """Endpoint creating an AI Agent for a given room."""
-        global MANAGER
-        if MANAGER is None:
-            MANAGER = AIAgentsManager()
+        global AI_AGENTS_MANAGER
+        if AI_AGENTS_MANAGER is None:
+            AI_AGENTS_MANAGER = AIAgentsManager()
         request_body = json.loads(self.request.body)
         agent_request = AgentRequestModel(**request_body)
-        self.log.info("Create AI Agents is requested [%s]", agent_request.model_dump())
+        self.log.info("AI Agents create handler requested with [%s]", agent_request.model_dump())
         room_id = agent_request.room_id
-        if room_id in MANAGER:
+        if room_id in AI_AGENTS_MANAGER:
             self.log.info("AI Agent for room [%s] already exists.", room_id)
-            # TODO check agent
+            # TODO check the ai agent.
             return {
                 "success": True,
                 "message": "AI Agent already exists",
@@ -145,11 +131,11 @@ async def post(self, *args, **kwargs):
             jupyter_ingress = runtime.ingress
             jupyter_token = runtime.token
             kernel_id = runtime.kernel_id
-            # Start AI Agent
+            # Start AI Agent in a ThreadPoolExecutor.
             EXECUTOR.submit(prompt_ai_agent, room_id, jupyter_ingress, jupyter_token, kernel_id)
         res = json.dumps({
             "success": True,
-            "message": f"AI Agent started for room '{room_id}'.",
+            "message": f"AI Agent is started for room '{room_id}'.",
         })
-        print(res)
+        logger.info("AI Agent create request exiting with reponse [%s]", res)
         self.finish(res)

docs/_tmp/llama3/index.mdx

@@ -41,15 +41,12 @@ def __init__(self) -> None:
         # A usefull task will be set when the first agent is added.
         self._stop_task: asyncio.Task = asyncio.create_task(asyncio.sleep(0))
 
-
     def __contains__(self, key: str) -> bool:
         return key in self._agents
 
-
     def __getitem__(self, key: str) -> RuntimeAgent:
         return self._agents[key]
 
-
     async def _stop_lonely_agents(self) -> None:
         """Periodically check if an agent as connected peer.
 
@@ -83,7 +80,6 @@ async def _stop_lonely_agents(self) -> None:
                 self._to_stop_counter.pop(key, None)
                 logger.info("AI Agent for room [%s] stopped.", key)
 
-
     async def stop_all(self) -> None:
         """Stop all background tasks and reset the state."""
         if self._stop_task.cancel():
@@ -98,23 +94,23 @@ async def stop_all(self) -> None:
         self._agents_to_stop.clear()
         self._to_stop_counter.clear()
 
-
     def get_user_agents(self, user: str) -> list[str]:
         return [k for k, a in self._agents.items() if a._username == user]
 
+    def register_ai_agent(self, key: str, agent: RuntimeAgent):
+        self._agents[key] = agent        
 
     async def track_agent(self, key: str, agent: RuntimeAgent) -> None:
         """Add an agent and start it."""
         if self._stop_task.done():
             self._stop_task = asyncio.create_task(self._stop_lonely_agents())
-        self._agents[key] = agent
+        self.register_ai_agent(key, agent)
         start = asyncio.create_task(await agent.start())
         self._background_tasks.append(start)
         start.add_done_callback(lambda task: self._background_tasks.remove(task))
         if agent.runtime_client is not None:
             agent.runtime_client.start()
 
-
     def forget_agent(self, key: str) -> None:
         if key in self:
             logger.info("Removing AI Agent in room [%s].", key)

jupyter_ai_agents/__version__.py

@@ -0,0 +1,22 @@
+# Copyright (c) 2023-2024 Datalayer, Inc.
+#
+# BSD 3-Clause License
+
+from __future__ import annotations
+
+
+from typing import Optional
+
+from pydantic import BaseModel
+
+
+class RuntimeModel(BaseModel):
+    ingress: Optional[str] = None
+    token: Optional[str] = None
+    kernel_id: Optional[str] = None
+    jupyter_pod_name: Optional[str] = None
+
+
+class AgentRequestModel(BaseModel):
+    room_id: Optional[str] = None
+    runtime: Optional[RuntimeModel] = None