jupyter-agent 2025.6.104__py3-none-any.whl → 2025.7.100__py3-none-any.whl

jupyter_agent/bot_actions.py

@@ -0,0 +1,270 @@
+"""
+Copyright (c) 2025 viewstar000
+
+This software is released under the MIT License.
+https://opensource.org/licenses/MIT
+"""
+
+import json
+import time
+import uuid
+import threading
+import queue
+import traceback
+import importlib
+import socket
+
+from enum import Enum
+from typing import Optional, Dict, List, Any
+from pydantic import BaseModel, Field
+from wsgiref.simple_server import make_server
+from bottle import default_app, get, post, request, response
+from .utils import get_env_capbilities
+
+
+class ActionBase(BaseModel):
+    timestamp: float = 0
+    uuid: str = ""
+    source: str = ""
+    action: str
+    params: Dict[str, Any] = {}
+
+    def __init__(self, **data):
+        super().__init__(**data)
+        self.timestamp = self.timestamp or time.time()
+        self.uuid = self.uuid or str(uuid.uuid4())
+
+
+class ReplyActionBase(ActionBase):
+    reply_host: str = ""
+    reply_port: int = 0
+
+
+class SetCellContentParams(BaseModel):
+    index: int = 1  # -1 previous, 0 current, 1 next
+    type: str = "code"  # code/markdown
+    source: str = ""
+    tags: List[str] = []
+    metadata: Dict[str, Any] = {}
+
+
+class ActionSetCellContent(ActionBase):
+
+    action: str = "set_cell_content"
+    params: SetCellContentParams = SetCellContentParams()
+
+
+class ConfirmChoiceItem(BaseModel):
+    label: str = ""
+    value: str
+
+
+class RequestUserConfirmParams(BaseModel):
+    prompt: str = ""
+    choices: List[ConfirmChoiceItem] = []
+    default: str = ""
+
+
+class ActionRequestUserConfirm(ReplyActionBase):
+
+    action: str = "request_user_confirm"
+    params: RequestUserConfirmParams = RequestUserConfirmParams()
+
+
+class ReceiveUserConfirmParams(BaseModel):
+    result: str = ""
+
+
+class ActionReceiveUserConfirm(ActionBase):
+
+    action: str = "receive_user_confirm"
+    params: ReceiveUserConfirmParams = ReceiveUserConfirmParams()
+
+
+class RequestUserSupplyInfo(BaseModel):
+    prompt: str = Field(
+        description="需要用户补充详细信息的Prompt",
+        examples=["请补充与...相关的详细的信息", "请确认...是否...", "请提供..."],
+    )
+    example: Optional[str] = Field(None, description="示例", examples=["..."])
+
+
+class UserSupplyInfoReply(BaseModel):
+    prompt: str = Field(description="需要用户补充详细信息的Prompt", examples=["..."])
+    reply: str = Field(description="用户补充的详细信息", examples=["..."])
+
+
+class RequestUserSupplyInfoParams(BaseModel):
+    title: str = ""
+    issues: List[RequestUserSupplyInfo] = []
+
+
+class ActionRequestUserSupplyInfo(ReplyActionBase):
+
+    action: str = "request_user_supply_info"
+    params: RequestUserSupplyInfoParams = RequestUserSupplyInfoParams()
+
+
+class ReceiveUserSupplyInfoParams(BaseModel):
+    replies: List[UserSupplyInfoReply] = Field(
+        description="完成补充确认的信息列表",
+        examples=[
+            UserSupplyInfoReply(prompt="请确认...是否...", reply="是"),
+            UserSupplyInfoReply(prompt="请补充...", reply="..."),
+        ],
+    )
+
+
+class ActionReceiveUserSupplyInfo(ActionBase):
+    action: str = "receive_user_supply_info"
+    params: ReceiveUserSupplyInfoParams = ReceiveUserSupplyInfoParams(replies=[])
+
+
+def request_user_reply(prompts: list[RequestUserSupplyInfo]) -> list[UserSupplyInfoReply]:
+    responses = []
+    for prompt in prompts:
+        response = input(f"{prompt.prompt} (例如: {prompt.example})")
+        responses.append(UserSupplyInfoReply(prompt=prompt.prompt, reply=response))
+    return responses
+
+
+def get_action_class(action_name: str) -> type[ActionBase]:
+    for obj in globals().values():
+        if isinstance(obj, type) and issubclass(obj, ActionBase):
+            if obj.__name__ == action_name or obj.model_fields["action"].default == action_name:
+                return obj
+    raise ValueError(f"Unknown action: {action_name}")
+
+
+class ActionReply(BaseModel):
+    reply_timestamp: float
+    retrieved_timestamp: float = 0
+    uuid: str
+    source: str = ""
+    action: str = ""
+    retrieved: bool = False
+    reply: ActionBase
+
+
+class ActionDispatcher(threading.Thread):
+    def __init__(self, host="127.0.0.1", port=0, app=None):
+        super().__init__(daemon=True)
+        self.action_queue = queue.Queue()
+        self.action_replies: dict[str, ActionReply] = {}
+        self.app = app or default_app()
+        self.host = host
+        self.port = port
+        self.server = None
+        if get_env_capbilities().user_confirm or get_env_capbilities().user_supply_info:
+            self.port = self.port or self.select_port(self.host)
+            self.server = make_server(self.host, self.port, self.app)
+            self.start()
+
+    def select_port(self, host):
+        sock = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
+        sock.setsockopt(socket.SOL_SOCKET, socket.SO_REUSEADDR, 1)
+        sock.bind((host, 0))
+        port = sock.getsockname()[1]
+        sock.close()
+        return port
+
+    def run(self):
+        if self.server is not None:
+            self.server.serve_forever()
+
+    def close(self):
+        if self.server is not None:
+            self.server.shutdown()
+            self.server.server_close()
+
+    def __del__(self):
+        self.close()
+
+    def __enter__(self):
+        return self
+
+    def __exit__(self, exc_type, exc_value, traceback):
+        self.close()
+
+    def send_action(self, action: ActionBase, need_reply: bool = False):
+
+        if need_reply:
+            assert isinstance(action, ReplyActionBase)
+            action.reply_host = self.host
+            action.reply_port = self.port
+        action.timestamp = action.timestamp or time.time()
+        action.uuid = action.uuid and str(uuid.uuid4())
+        self.action_queue.put(action.model_dump())
+        bot_outputs = importlib.import_module(".bot_outputs", __package__)
+        bot_outputs.output_action(action)
+
+    def get_action_reply(self, action: ReplyActionBase, wait: bool = True) -> Optional[ActionBase]:
+
+        while wait and action.uuid not in self.action_replies:
+            time.sleep(1)
+        if action.uuid in self.action_replies:
+            self.action_replies[action.uuid].retrieved = True
+            self.action_replies[action.uuid].retrieved_timestamp = time.time()
+        return self.action_replies.get(action.uuid) and self.action_replies[action.uuid].reply
+
+
+_default_action_dispatcher = None
+
+
+def get_action_dispatcher() -> ActionDispatcher:
+    global _default_action_dispatcher
+
+    if not _default_action_dispatcher:
+        _default_action_dispatcher = ActionDispatcher()
+    elif not _default_action_dispatcher.is_alive():
+        _default_action_dispatcher.close()
+        _default_action_dispatcher = ActionDispatcher()
+    return _default_action_dispatcher
+
+
+def close_action_dispatcher():
+    global _default_action_dispatcher
+
+    if _default_action_dispatcher:
+        _default_action_dispatcher.close()
+        _default_action_dispatcher = None
+
+
+@get("/echo")
+def echo():
+    response.content_type = "application/json"
+    return json.dumps({"status": "OK"})
+
+
+@post("/action_reply")
+def action_reply():
+    try:
+        uuid = request.GET["uuid"]  # type: ignore
+        action = request.GET.get("a") or request.json.get("action")  # type: ignore
+        source = request.GET.get("s") or request.json.get("source")  # type: ignore
+        reply = get_action_class(action)(**request.json)  # type: ignore
+        action_reply = ActionReply(reply_timestamp=time.time(), uuid=uuid, source=source, action=action, reply=reply)
+        get_action_dispatcher().action_replies[action_reply.uuid] = action_reply
+        response.content_type = "application/json"
+        return json.dumps({"status": "OK"})
+    except Exception as e:
+        response.content_type = "application/json"
+        return json.dumps(
+            {"status": "ERROR", "error": f"{type(e).__name__}: {e}", "traceback": traceback.format_exc()}
+        )
+
+
+@get("/action_fetch")
+def action_fetch():
+    try:
+        action = get_action_dispatcher().action_queue.get(block=False)
+        response.content_type = "application/json"
+        return json.dumps({"status": "OK", "action": action})
+    except queue.Empty:
+        response.content_type = "application/json"
+        return json.dumps({"status": "EMPTY"})
+    except Exception as e:
+        response.content_type = "application/json"
+        return json.dumps(
+            {"status": "ERROR", "error": f"{type(e).__name__}: {e}", "traceback": traceback.format_exc()}
+        )

jupyter_agent/bot_agents/__init__.py

@@ -1,42 +0,0 @@
-"""
-Copyright (c) 2025 viewstar000
-
-This software is released under the MIT License.
-https://opensource.org/licenses/MIT
-"""
-
-from .base import BaseChatAgent, AgentFactory
-from .master_planner import MasterPlannerAgent
-from .output_task_result import OutputTaskResult
-from .task_code_executor import CodeExecutor
-from .task_planner_v1 import TaskPlannerAgentV1
-from .task_planner_v2 import TaskPlannerAgentV2
-from .task_planner_v3 import TaskPlannerAgentV3
-from .task_coder import TaskCodingAgent
-from .task_debuger import CodeDebugerAgent
-from .task_verifier import TaskVerifyAgent, TaskVerifyState
-from .task_summarier import TaskSummaryAgent
-from .task_verify_summarier import TaskVerifySummaryAgent
-from .task_structrue_summarier import TaskStructureSummaryAgent
-from .task_reasoner import TaskReasoningAgent
-from .task_structrue_reasoner import TaskStructureReasoningAgent
-
-__all__ = [
-    "AgentFactory",
-    "BaseChatAgent",
-    "CodeDebugerAgent",
-    "CodeExecutor",
-    "MasterPlannerAgent",
-    "TaskCodingAgent",
-    "TaskPlannerAgentV1",
-    "TaskPlannerAgentV2",
-    "TaskPlannerAgentV3",
-    "TaskReasoningAgent",
-    "TaskStructureReasoningAgent",
-    "TaskStructureSummaryAgent",
-    "TaskSummaryAgent",
-    "TaskVerifyAgent",
-    "TaskVerifyState",
-    "TaskVerifySummaryAgent",
-    "OutputTaskResult",
-]

jupyter_agent/bot_agents/base.py

@@ -7,11 +7,13 @@ https://opensource.org/licenses/MIT
 
 import json
 import importlib
+import traceback
 
 from typing import Tuple, Any
 from enum import Enum, unique
+from pydantic import BaseModel, Field
 from IPython.display import Markdown
-from ..bot_outputs import _C, flush_output
+from ..bot_outputs import _C, _O, _W, _T, flush_output
 from ..bot_chat import BotChat
 from ..utils import no_indent
 
@@ -133,6 +135,7 @@ class AgentModelType(str, Enum):
     DEFAULT = "default"
     PLANNER = "planner"
     CODING = "coding"
+    EVALUATING = "evaluating"
     REASONING = "reasoning"
 
 
@@ -150,6 +153,9 @@ class BaseAgent:
     def cells(self):
         return self.notebook_context.cells
 
+    def __call__(self, **kwds: Any) -> Tuple[bool, Any]:
+        raise NotImplementedError
+
 
 class BaseChatAgent(BotChat, BaseAgent):
     """基础聊天代理类"""
@@ -161,12 +167,13 @@ class BaseChatAgent(BotChat, BaseAgent):
     DISPLAY_REPLY = True
     COMBINE_REPLY = AgentCombineReply.MERGE
     ACCEPT_EMPYT_REPLY = False
+    REPLY_ERROR_RETRIES = 1
     MODEL_TYPE = AgentModelType.REASONING
 
-    def __init__(self, notebook_context, base_url, api_key, model_name, **chat_kwargs):
+    def __init__(self, notebook_context, **chat_kwargs):
         """初始化基础任务代理"""
         BaseAgent.__init__(self, notebook_context)
-        BotChat.__init__(self, base_url, api_key, model_name, **chat_kwargs)
+        BotChat.__init__(self, **chat_kwargs)
 
     def prepare_contexts(self, **kwargs):
         contexts = {
@@ -185,8 +192,16 @@ class BaseChatAgent(BotChat, BaseAgent):
                 }
             else:
                 json_example = {}
-            contexts["OUTPUT_JSON_SCHEMA"] = json.dumps(json_schema, indent=2, ensure_ascii=False)
-            contexts["OUTPUT_JSON_EXAMPLE"] = json.dumps(json_example, indent=2, ensure_ascii=False)
+
+            def _default(o):
+                if isinstance(o, BaseModel):
+                    return o.model_dump()
+                if isinstance(o, Enum):
+                    return o.value
+                return repr(o)
+
+            contexts["OUTPUT_JSON_SCHEMA"] = json.dumps(json_schema, indent=2, ensure_ascii=False, default=_default)
+            contexts["OUTPUT_JSON_EXAMPLE"] = json.dumps(json_example, indent=2, ensure_ascii=False, default=_default)
         contexts.update(kwargs)
         return contexts
 
@@ -220,30 +235,41 @@ class BaseChatAgent(BotChat, BaseAgent):
 
     def combine_json_replies(self, replies):
         json_replies = [reply for reply in replies if reply["type"] == "code" and reply["lang"] == "json"]
-        if self.COMBINE_REPLY == AgentCombineReply.FIRST:
-            json_obj = json.loads(json_replies[0]["content"])
-            if self.OUTPUT_JSON_SCHEMA:
-                json_obj = self.OUTPUT_JSON_SCHEMA(**json_obj)
-            return json_obj
-        elif self.COMBINE_REPLY == AgentCombineReply.LAST:
-            json_obj = json.loads(json_replies[-1]["content"])
-            if self.OUTPUT_JSON_SCHEMA:
-                json_obj = self.OUTPUT_JSON_SCHEMA(**json_obj)
-            return json_obj
-        elif self.COMBINE_REPLY == AgentCombineReply.LIST:
-            json_objs = [json.loads(reply["content"]) for reply in json_replies]
-            if self.OUTPUT_JSON_SCHEMA:
-                json_objs = [self.OUTPUT_JSON_SCHEMA(**json_obj) for json_obj in json_objs]
-            return json_objs
-        elif self.COMBINE_REPLY == AgentCombineReply.MERGE:
-            json_obj = {}
-            for json_reply in json_replies:
-                json_obj.update(json.loads(json_reply["content"]))
-            if self.OUTPUT_JSON_SCHEMA:
-                json_obj = self.OUTPUT_JSON_SCHEMA(**json_obj)
-            return json_obj
-        else:
-            raise ValueError("Unsupported combine_reply: {} for json output".format(self.COMBINE_REPLY))
+        assert self.COMBINE_REPLY in [
+            AgentCombineReply.FIRST,
+            AgentCombineReply.LAST,
+            AgentCombineReply.LIST,
+            AgentCombineReply.MERGE,
+        ]
+        try:
+            if self.COMBINE_REPLY == AgentCombineReply.FIRST:
+                json_obj = json.loads(json_replies[0]["content"])
+                if self.OUTPUT_JSON_SCHEMA:
+                    json_obj = self.OUTPUT_JSON_SCHEMA(**json_obj)
+                return json_obj
+            elif self.COMBINE_REPLY == AgentCombineReply.LAST:
+                json_obj = json.loads(json_replies[-1]["content"])
+                if self.OUTPUT_JSON_SCHEMA:
+                    json_obj = self.OUTPUT_JSON_SCHEMA(**json_obj)
+                return json_obj
+            elif self.COMBINE_REPLY == AgentCombineReply.LIST:
+                json_objs = [json.loads(reply["content"]) for reply in json_replies]
+                if self.OUTPUT_JSON_SCHEMA:
+                    json_objs = [self.OUTPUT_JSON_SCHEMA(**json_obj) for json_obj in json_objs]
+                return json_objs
+            elif self.COMBINE_REPLY == AgentCombineReply.MERGE:
+                json_obj = {}
+                for json_reply in json_replies:
+                    json_obj.update(json.loads(json_reply["content"]))
+                if self.OUTPUT_JSON_SCHEMA:
+                    json_obj = self.OUTPUT_JSON_SCHEMA(**json_obj)
+                return json_obj
+            else:
+                return False
+        except Exception as e:
+            _T(f"提取JSON失败: {type(e).__name__}: {e}")
+            _W(traceback.format_exc())
+            return False
 
     def combine_text_replies(self, replies):
         text_replies = [reply for reply in replies if reply["type"] == "text"]
@@ -274,10 +300,22 @@ class BaseChatAgent(BotChat, BaseAgent):
     def __call__(self, **kwargs) -> Tuple[bool, Any]:
         contexts = self.prepare_contexts(**kwargs)
         messages = self.create_messages(contexts)
-        replies = self.chat(messages.get(), display_reply=self.DISPLAY_REPLY)
-        reply = self.combine_replies(replies)
-        if not self.ACCEPT_EMPYT_REPLY and not reply:
-            raise ValueError("Reply is empty")
+        reply_retries = 0
+        while reply_retries <= self.REPLY_ERROR_RETRIES:
+            replies = self.chat(messages.get(), display_reply=self.DISPLAY_REPLY)
+            reply = self.combine_replies(replies)
+            if reply is False:
+                reply_retries += 1
+                if reply_retries > self.REPLY_ERROR_RETRIES:
+                    raise ValueError("Failed to get reply")
+                _W("Failed to get reply, retrying...")
+            elif not self.ACCEPT_EMPYT_REPLY and not reply:
+                reply_retries += 1
+                if reply_retries > self.REPLY_ERROR_RETRIES:
+                    raise ValueError("Reply is empty")
+                _W("Reply is empty, retrying...")
+            else:
+                break
         result = self.on_reply(reply)
         flush_output()
         if not isinstance(result, tuple):
@@ -300,25 +338,31 @@ class AgentFactory:
             "model": model_name,
         }
 
-    def __call__(self, agent_class):
-
+    def get_agent_class(self, agent_class):
         if isinstance(agent_class, str):
             bot_agents = importlib.import_module("..bot_agents", __package__)
             agent_class = getattr(bot_agents, agent_class)
+        assert issubclass(agent_class, BaseAgent), "Unsupported agent class: {}".format(agent_class)
+        return agent_class
 
+    def get_chat_kwargs(self, agent_class):
         if issubclass(agent_class, BaseChatAgent):
             agent_model = agent_class.MODEL_TYPE if hasattr(agent_class, "MODEL_TYPE") else AgentModelType.DEFAULT
-            return agent_class(
-                notebook_context=self.notebook_context,
-                base_url=self.models.get(agent_model, {}).get("api_url")
+            chat_kwargs = {
+                "base_url": self.models.get(agent_model, {}).get("api_url")
                 or self.models[AgentModelType.DEFAULT]["api_url"],
-                api_key=self.models.get(agent_model, {}).get("api_key")
+                "api_key": self.models.get(agent_model, {}).get("api_key")
                 or self.models[AgentModelType.DEFAULT]["api_key"],
-                model_name=self.models.get(agent_model, {}).get("model")
+                "model_name": self.models.get(agent_model, {}).get("model")
                 or self.models[AgentModelType.DEFAULT]["model"],
-                **self.chat_kwargs,
-            )
-        elif issubclass(agent_class, BaseAgent):
-            return agent_class(notebook_context=self.notebook_context)
+            }
+            chat_kwargs.update(self.chat_kwargs)
+            return chat_kwargs
         else:
-            raise ValueError("Unsupported agent class: {}".format(agent_class))
+            return {}
+
+    def __call__(self, agent_class):
+
+        agent_class = self.get_agent_class(agent_class)
+        chat_kwargs = self.get_chat_kwargs(agent_class)
+        return agent_class(self.notebook_context, **chat_kwargs)

jupyter_agent/bot_agents/master_planner.py

@@ -42,4 +42,5 @@ class MasterPlannerAgent(BaseChatAgent):
     MODEL_TYPE = AgentModelType.PLANNER
 
     def on_reply(self, reply):
+        self.task.agent_data.result = ""
         _C(Markdown(reply), reply_type=ReplyType.TASK_RESULT)

jupyter_agent/bot_agents/output_task_result.py

@@ -17,13 +17,12 @@ class OutputTaskResult(BaseAgent):
     def __call__(self):
         """执行代码逻辑"""
         if self.task.result:
-            _O(Markdown("### 任务结果\n\n"))
-            _C(Markdown(self.task.result), reply_type=ReplyType.TASK_RESULT)
+            _M("### 任务结果\n\n" + self.task.result)
         if self.task.important_infos:
-            _O(
-                markdown_block(
-                    f"```json\n{json.dumps(self.task.important_infos, indent=4, ensure_ascii=False)}\n```",
-                    title="重要信息",
-                )
+            _B(
+                json.dumps(self.task.important_infos, indent=4, ensure_ascii=False),
+                title="重要信息",
+                format="code",
+                code_language="json",
             )
         return False, None

jupyter_agent/bot_agents/prepare_next_cell.py

@@ -0,0 +1,52 @@
+"""
+Copyright (c) 2025 viewstar000
+
+This software is released under the MIT License.
+https://opensource.org/licenses/MIT
+"""
+
+import json
+import datetime
+
+from IPython.display import Markdown
+from .base import BaseAgent
+from ..bot_outputs import _D, _I, _W, _E, _F, _M, _B, _C, _O, ReplyType, markdown_block
+from ..bot_actions import get_action_dispatcher, ActionSetCellContent, SetCellContentParams
+from ..utils import get_env_capbilities
+
+
+class PrepareNextCell(BaseAgent):
+
+    def __call__(self):
+        """执行代码逻辑"""
+        if get_env_capbilities().set_cell_content:
+            _I("set next cell content to generate the next task")
+            get_action_dispatcher().send_action(
+                ActionSetCellContent(
+                    source=self.__class__.__name__,
+                    params=SetCellContentParams(
+                        index=1,
+                        type="code",
+                        source=(
+                            "%%bot\n\n"
+                            "# Execute this cell to generate the next task\n"
+                            "# {}\n"
+                            "# Special Note: Ensure the notebook is SAVED before executing this cell!\n"
+                        ).format(datetime.datetime.now().isoformat()),
+                    ),
+                ),
+                need_reply=False,
+            )
+        else:
+            _M("Copy the following code to the next cell to generate the next task ...")
+            _M(
+                (
+                    "```python\n"
+                    "%%bot\n\n"
+                    "# Execute this cell to generate the next task\n"
+                    "# {}\n"
+                    "# Special Note: Ensure the notebook is SAVED before executing this cell!\n"
+                    "```"
+                ).format(datetime.datetime.now().isoformat())
+            )
+        return False, None