python-codex 0.2.7__py3-none-any.whl → 0.3.0__py3-none-any.whl

pycodex/feishu_link.py

@@ -3,9 +3,9 @@ import threading
 import time
 import typing
 
+from .events import SessionStateEvent
 from .feishu_card import PycodexCard
-from .protocol import AssistantMessage, UserMessage
-from .runtime import CliSubmissionQueue
+from .runtime import AgentRuntime
 
 CARD_UPDATE_FLUSH_INTERVAL_SECONDS = 0.5
 _LISTENER = None
@@ -15,39 +15,39 @@ _LISTENER_LOCK = threading.Lock()
 class PycodexRuntimeLink:
     def __init__(
         self,
-        queue: 'CliSubmissionQueue',
+        runtime: "AgentRuntime",
         target: str,
         loop=None,
-        card: 'typing.Union[PycodexCard, None]' = None,
+        card: "typing.Union[PycodexCard, None]" = None,
     ) -> None:
-        self.queue = queue
+        self.runtime = runtime
         self.target = target
         self.loop = loop
         self.card = card or PycodexCard.from_env()
         self.session_key = None
         self.message_id = None
         self._listener = None
-        self._previous_event_handler = None
-        self._event_handler = None
+        self._frontend_id = None
         self._detached = False
         self._update_thread = None
         self._update_stop = threading.Event()
         self._update_lock = threading.Lock()
         self._update_pending = False
 
-    async def start_async(self) -> 'PycodexRuntimeLink':
+    async def start_async(self) -> "PycodexRuntimeLink":
         self.loop = asyncio.get_event_loop()
-        return await self.loop.run_in_executor(None, self.start)
+        self.card.apply_event(SessionStateEvent("attach", self.runtime.snapshot()))
+        try:
+            await self.loop.run_in_executor(None, self.start)
+        except Exception:
+            await self.loop.run_in_executor(None, self.stop)
+            raise
+        self._frontend_id = self.runtime.attach(self._handle_runtime_event)
+        return self
 
-    def start(self) -> 'PycodexRuntimeLink':
+    def start(self) -> "PycodexRuntimeLink":
         if self.loop is None:
             raise RuntimeError("PycodexRuntimeLink.start_async() is required")
-        self.card.set_snapshot(*_last_user_assistant_pair(self.queue))
-        if self._has_active_turn():
-            self.card.status = "Running"
-            self.card.status_detail = "Model request started."
-            self.card.running = True
-        self.card.model_name = getattr(self.queue._agent._model_client, 'model', 'pycodex')
         self.card.send(self.target)
         self.session_key = self.card.session_key
         self.message_id = self.card.message_id
@@ -55,11 +55,10 @@ class PycodexRuntimeLink:
         self._listener.register(self)
         self._listener.start()
         self._start_update_thread()
-        self._install_event_handler()
         return self
 
     def stop(self) -> None:
-        self._restore_event_handler()
+        self._detach_frontend()
         if self._listener is not None:
             _release_feishu_listener(self._listener, self)
             self._listener = None
@@ -67,7 +66,7 @@ class PycodexRuntimeLink:
 
     def detach(self) -> None:
         self._detached = True
-        self._restore_event_handler()
+        self._detach_frontend()
         if self._listener is not None:
             _release_feishu_listener(self._listener, self)
             self._listener = None
@@ -75,29 +74,29 @@ class PycodexRuntimeLink:
         self._safe_update_card()
         self._stop_update_thread()
 
-    def _restore_event_handler(self) -> None:
-        current = getattr(self.queue, "_event_handler", None)
-        if current is self._event_handler and self._previous_event_handler is not None:
-            self.queue.set_event_handler(self._previous_event_handler)
-
-    def _install_event_handler(self) -> None:
-        self._previous_event_handler = getattr(self.queue, "_event_handler", None)
-        self._event_handler = self._handle_runtime_event
-        self.queue.set_event_handler(self._event_handler)
+    def _detach_frontend(self) -> None:
+        if self._frontend_id is not None:
+            self.runtime.detach(self._frontend_id)
+            self._frontend_id = None
 
     def _handle_runtime_event(self, event) -> None:
-        if self._previous_event_handler is not None:
-            self._previous_event_handler(event)
         if self._detached:
             return
         self.card.apply_event(event)
         self._update_card()
 
-    async def _submit(self, action: 'typing.Dict[str, object]') -> 'typing.Dict[str, object]':
+    async def _submit(
+        self, action: "typing.Dict[str, object]"
+    ) -> "typing.Dict[str, object]":
         if self._detached:
             return {"toast": {"type": "warning", "content": "pycodex is detached."}}
-        if self.card.running or self._has_active_turn():
-            return {"toast": {"type": "warning", "content": "pycodex is running."}}
+        if action.get("action") == "history":
+            try:
+                self.card.show_history(action.get("history_index"))
+            except ValueError as exc:
+                return {"toast": {"type": "warning", "content": str(exc)}}
+            self._update_card()
+            return {}
         if action.get("action") != "send":
             return {
                 "toast": {
@@ -106,46 +105,22 @@ class PycodexRuntimeLink:
                 }
             }
         prompt = str(action.get("prompt") or "").strip()
-        if not prompt:
-            return {"toast": {"type": "warning", "content": "Prompt is empty."}}
-        self.card.set_queued(prompt, sender=str(action.get("sender") or "cli"))
-        self._update_card()
-        queue_name = "steer" if self._has_active_turn() else "enqueue"
         future = asyncio.run_coroutine_threadsafe(
-            self.queue.enqueue_user_turn(prompt, queue=queue_name),
+            self.runtime.submit_input(
+                prompt, sender=str(action.get("sender") or "feishu")
+            ),
             self.loop,
         )
-        submission_id, turn_future = await asyncio.wrap_future(future)
-
-        def on_done(completed):
-            if self._detached:
-                return
-            if completed.cancelled():
-                self.card.status = "Idle"
-                self.card.status_detail = "submission cancelled"
-                self.card.running = False
-                self._update_card()
-                return
-            exc = completed.exception()
-            if exc is not None:
-                self.card.status = "Error"
-                self.card.status_detail = str(exc)
-                self.card.error = str(exc)
-                self.card.running = False
-                self._update_card()
-
-        del submission_id
-        self.loop.call_soon_threadsafe(lambda: turn_future.add_done_callback(on_done))
-        return {"toast": {"type": "info", "content": "pycodex is running."}}
+        try:
+            await asyncio.wrap_future(future)
+        except (ValueError, RuntimeError) as exc:
+            return {"toast": {"type": "warning", "content": str(exc)}}
+        return {"toast": {"type": "info", "content": "Input submitted."}}
 
     def _update_card(self) -> None:
         with self._update_lock:
             self._update_pending = True
 
-    def _has_active_turn(self) -> bool:
-        task = getattr(self.queue, "_current_task", None)
-        return task is not None and not task.done()
-
     def _safe_update_card(self) -> None:
         try:
             self.card.update()
@@ -179,22 +154,7 @@ class PycodexRuntimeLink:
             self._safe_update_card()
 
 
-def _last_user_assistant_pair(queue) -> 'typing.Tuple[str, str]':
-    agent = getattr(queue, "_agent", None)
-    history = getattr(agent, "history", ())
-    output = ""
-    prompt = ""
-    for item in reversed(history):
-        if not output and isinstance(item, AssistantMessage):
-            output = item.text
-            continue
-        if output and isinstance(item, UserMessage):
-            prompt = item.text
-            break
-    return prompt, output
-
-
-def _feishu_listener(card: PycodexCard) -> '_FeishuCardActionListener':
+def _feishu_listener(card: PycodexCard) -> "_FeishuCardActionListener":
     global _LISTENER
     with _LISTENER_LOCK:
         if _LISTENER is None:
@@ -205,7 +165,7 @@ def _feishu_listener(card: PycodexCard) -> '_FeishuCardActionListener':
 
 
 def _release_feishu_listener(
-    listener: '_FeishuCardActionListener',
+    listener: "_FeishuCardActionListener",
     link: PycodexRuntimeLink,
 ) -> None:
     global _LISTENER
@@ -343,7 +303,7 @@ class _FeishuCardActionListener:
             _close_loop(loop)
             asyncio.set_event_loop(None)
 
-    def _handle_card_action(self, event) -> 'typing.Dict[str, object]':
+    def _handle_card_action(self, event) -> "typing.Dict[str, object]":
         try:
             message_id = _event_message_id(event)
             link = self._resolve_link(message_id)