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

pycodex/feishu_card.py

@@ -1,11 +1,22 @@
 import json
 import os
-from pathlib import Path
 import time
 import typing
+from pathlib import Path
 
 import requests
 
+from .events import (
+    DEFAULT_MAIN_PROMPT,
+    Event,
+    EventDisplay,
+    InputQueuedEvent,
+    SessionStateEvent,
+    TurnCompletedEvent,
+    TurnStartedEvent,
+)
+from .utils.event_helpers import completed_history
+
 FEISHU_API_BASE = "https://open.feishu.cn/open-apis"
 FEISHU_DOMAIN = "https://open.feishu.cn"
 FEISHU_REFRESH_TOKEN_FILE = "~/.codex/.feishu_refresh_token"
@@ -13,7 +24,6 @@ CARD_OUTPUT_LIMIT = 6500
 CARD_OUTPUT_MODE_MARKDOWN = "markdown"
 CARD_OUTPUT_MODE_CODE = "code"
 CARD_CONTENT_ERROR_MARKER = "Failed to create card content"
-LAST_TURN_PREFIX = "(*last turn)\n"
 
 
 class PycodexCard:
@@ -25,7 +35,6 @@ class PycodexCard:
         domain: str = FEISHU_DOMAIN,
         verification_token: "typing.Union[str, None]" = None,
         encrypt_key: "typing.Union[str, None]" = None,
-        refresh_token: "typing.Union[str, None]" = None,
         session: "typing.Union[requests.Session, None]" = None,
     ) -> None:
         self.app_id = app_id
@@ -34,22 +43,23 @@ class PycodexCard:
         self.domain = domain
         self.verification_token = verification_token
         self.encrypt_key = encrypt_key
-        self.refresh_token = refresh_token
         self.session = session or requests.Session()
         self.message_id = None
         self.callback_token = None
         self.session_key = None
-        self.status = "Idle"
-        self.status_detail = "Ready."
-        self.last_sender = "cli"
-        self.last_prompt = ""
+        self.status = None
+        self.prompt_text = DEFAULT_MAIN_PROMPT
         self.model_name = "pycodex"
         self.output_text = ""
-        self.working_output_text = ""
-        self._working_delta_active = False
-        self.error = ""
-        self.running = False
+        self.activity_text = ""
+        self.user_prompt = ""
+        self.turn_history = []
+        self.history_index = None
+        self._active_turn_id = None
+        self._event_output = ""
+        self.display = EventDisplay(self._log, self._set_status, self._set_prompt)
         self.detached = False
+        self.accepts_input = True
         self._user_access_token = None
         self._user_token_expires_at = 0.0
         self._tenant_token = None
@@ -68,7 +78,6 @@ class PycodexCard:
                 "LARK_VERIFICATION_TOKEN",
             ),
             encrypt_key=_env("FEISHU_ENCRYPT_KEY", "LARK_ENCRYPT_KEY"),
-            refresh_token=_read_refresh_token() or os.environ.get("FEISHU_REFRESH_TOKEN"),
         )
 
     def configured(self) -> bool:
@@ -146,145 +155,92 @@ class PycodexCard:
                 use_user_token=False,
             )
 
-    def set_queued(self, prompt: str, sender: str = "cli") -> None:
-        self.status = "Queued"
-        self.status_detail = "Waiting for pycodex."
-        self.last_sender = sender or "cli"
-        self.last_prompt = prompt
-        self._mark_last_turn_output()
-        self._reset_working_output()
-        self.error = ""
-        self.running = True
-
-    def set_snapshot(self, prompt: str, output: str) -> None:
-        self.last_prompt = prompt or self.last_prompt
-        self.output_text = output or self.output_text
-
     def detach(self) -> None:
-        self.status = "Detached"
-        self.status_detail = ""
-        self.error = ""
-        self.running = False
         self.detached = True
 
-    def apply_event(self, event) -> bool:
-        kind = getattr(event, "kind", None)
-        if kind is None and isinstance(event, dict):
-            kind = event.get("kind", "")
-        kind = str(kind or "")
-        payload = getattr(event, "payload", None)
-        if payload is None and isinstance(event, dict):
-            payload = event
-        if not isinstance(payload, dict):
-            payload = {}
-        if kind == "turn_started":
-            self.status = "Running"
-            self.status_detail = "Model request started."
-            was_running = self.running
-            self.running = True
-            self._reset_working_output()
-            prompt = payload.get("user_text") or "\n".join(
-                str(item) for item in payload.get("user_texts", []) or []
-            )
-            if prompt:
-                prompt_text = str(prompt)
-                if not (was_running and prompt_text == self.last_prompt):
-                    self.last_sender = "cli"
-                self.last_prompt = prompt_text
+    def apply_event(self, event: "Event") -> None:
+        self._event_output = ""
+        if isinstance(event, SessionStateEvent):
+            state = event.state
+            self.model_name = state["model"]
+            self.accepts_input = state["accepts_input"]
+            self.display.closed = state["closed"]
+            if event.reason in {"attach", "history"}:
+                self.output_text = ""
+                self.activity_text = ""
+                self.turn_history = list(completed_history(state))
+                self.history_index = None
+                active = state["active_turn"]
+                self._active_turn_id = active["turn_id"] if active is not None else None
+                self.user_prompt = (
+                    "\n".join(active["user_texts"])
+                    if active is not None
+                    else self.turn_history[-1][0] if self.turn_history else ""
+                )
+                self.display.stream_buffer = ""
+                self.prompt_text = DEFAULT_MAIN_PROMPT
+                if state["busy"]:
+                    self._set_status("working")
+                else:
+                    self.display.set_idle_status(state["background_work_count"])
+                for _prompt, response in self.turn_history[-1:]:
+                    self.output_text = response
+                if state["busy"]:
+                    self._mark_last_turn_output()
+        elif isinstance(event, (InputQueuedEvent, TurnStartedEvent)):
             self._mark_last_turn_output()
-            self.error = ""
-            return False
-        if kind == "assistant_delta":
-            self.status = "Responding"
-            self.status_detail = "Receiving assistant output."
-            self._append_working_delta(str(payload.get("delta") or ""))
-            return False
-        if kind == "tool_started":
-            self.status = "Tool"
-            self.status_detail = str(payload.get("tool_name") or "tool")
-            self._finish_working_delta_segment()
-            return False
-        if kind == "tool_completed":
-            self.status_detail = str(
-                payload.get("summary") or payload.get("tool_name") or "tool completed"
-            )
-            self._finish_working_delta_segment()
-            return False
-        if kind == "stream_error":
-            self.status = "Retrying"
-            self.status_detail = str(
-                payload.get("summary") or payload.get("message") or ""
-            )
-            return False
-        if kind == "turn_completed":
-            final_text = str(payload.get("output_text") or "")
-            if final_text:
-                self.output_text = final_text
-            self.status = "Idle"
-            self.status_detail = "Turn completed."
-            self.running = False
-            self._reset_working_output()
-            return True
-        if kind in {"turn_failed", "submission_failed"}:
-            self.status = "Error"
-            self.error = str(payload.get("error") or kind)
-            self.status_detail = self.error
-            self.running = False
-            self._finish_working_delta_segment()
-            return True
-        if kind in {"turn_interrupted", "submission_cancelled"}:
-            self.status = "Idle"
-            self.status_detail = kind.replace("_", " ")
-            self.running = False
-            self._reset_working_output()
-            return True
-        return False
+            if isinstance(event, TurnStartedEvent):
+                prompt = event.visualize()
+                if event.turn_id == self._active_turn_id and self.user_prompt:
+                    self.user_prompt += "\n" + prompt
+                else:
+                    self.user_prompt = prompt
+                self._active_turn_id = event.turn_id
+        event.render(self.display)
+        if isinstance(event, TurnCompletedEvent):
+            if event.output_text:
+                self.output_text = event.output_text
+                self.turn_history.append((self.user_prompt, event.output_text))
+            self.activity_text = ""
+            self._active_turn_id = None
+        elif isinstance(event, TurnStartedEvent):
+            self.activity_text = ""
+        elif self._event_output:
+            self.activity_text = self._event_output
 
     def _mark_last_turn_output(self) -> None:
-        if self.output_text and not self.output_text.startswith(LAST_TURN_PREFIX):
-            self.output_text = LAST_TURN_PREFIX + self.output_text
+        prefix = "(*last turn)\n"
+        if self.output_text and not self.output_text.startswith(prefix):
+            self.output_text = prefix + self.output_text
 
-    def _reset_working_output(self) -> None:
-        self.working_output_text = ""
-        self._working_delta_active = False
+    def _log(self, text: str) -> None:
+        self._event_output = (
+            self._event_output + ("\n" if self._event_output else "") + text
+        )[-CARD_OUTPUT_LIMIT:]
 
-    def _finish_working_delta_segment(self) -> None:
-        self._working_delta_active = False
+    def _set_status(self, text: "typing.Union[str, None]") -> None:
+        self.status = text
 
-    def _append_working_delta(self, delta: str) -> None:
-        if not delta:
-            return
-        if self._working_delta_active:
-            self.working_output_text += delta
-        else:
-            self.working_output_text = delta
-            self._working_delta_active = True
+    def _set_prompt(self, text: str) -> None:
+        if text != self.prompt_text:
+            self.activity_text = ""
+        self.prompt_text = text
 
     def render(
         self, output_mode: str = CARD_OUTPUT_MODE_MARKDOWN
     ) -> "typing.Dict[str, object]":
-        idle = str(self.status or "").lower() == "idle"
-        status_line = _escape_markdown(self.status)
-        if self.status_detail:
-            status_line += " - " + _escape_markdown(self.status_detail)
-        if self.error:
-            status_line += " - " + _escape_markdown(self.error)
-        input_disabled = self.running or self.detached
-        sender = _escape_markdown(self.last_sender or "cli")
-        prompt = _truncate(self.last_prompt, 1200) or "-"
-        output = _truncate(self.output_text, CARD_OUTPUT_LIMIT) or (
-            "Waiting for output..." if self.running else "Ready."
-        )
-        output_content = _render_output_content(output, output_mode)
-        working_output = _truncate(self.working_output_text, CARD_OUTPUT_LIMIT)
-        color, title = _status_template(self.status)
+        status = "Closed" if self.display.closed else self.status
+        input_disabled = not self.accepts_input or self.detached or self.display.closed
+        output = _truncate(self.output_text, CARD_OUTPUT_LIMIT) or "Ready."
+        working_output = _truncate(self.display.stream_buffer, CARD_OUTPUT_LIMIT)
+        color = _status_color("Detached" if self.detached else status or "Idle")
         body_elements = [
-            {
-                "tag": "markdown",
-                "element_id": "prompt_md",
-                "content": f"> {sender}: **{_escape_code_block(prompt)}**",
-            },
-            _output_box("answer_box", "answer_md", output_content, "grey-50"),
+            _output_box(
+                "answer_box",
+                "answer_md",
+                _render_output_content(output, output_mode),
+                "grey-50",
+            ),
         ]
         if working_output:
             body_elements.append(
@@ -295,11 +251,49 @@ class PycodexCard:
                     "green-50",
                 )
             )
+        if self.activity_text:
+            body_elements.append(
+                {
+                    "tag": "markdown",
+                    "element_id": "activity_md",
+                    "content": _render_output_content(self.activity_text, output_mode),
+                }
+            )
+        if self.user_prompt:
+            body_elements.insert(
+                0,
+                {
+                    "tag": "markdown",
+                    "element_id": "user_prompt_md",
+                    "content": _render_output_content(
+                        "user> " + _truncate(self.user_prompt, CARD_OUTPUT_LIMIT),
+                        output_mode,
+                    ),
+                },
+            )
+        history = self.earlier_turns()
+        if history:
+            index = (
+                len(history) - 1 if self.history_index is None else self.history_index
+            )
+            body_elements.insert(
+                0,
+                _history_panel(
+                    history,
+                    index,
+                    self.history_index is not None,
+                    output_mode,
+                    not self.detached,
+                ),
+            )
         card = {
             "schema": "2.0",
             "config": {"update_multi": True},
             "header": {
-                "title": {"tag": "plain_text", "content": title},
+                "title": {
+                    "tag": "plain_text",
+                    "content": self.display.title or "pycodex",
+                },
                 "template": color,
             },
             "body": {
@@ -317,7 +311,7 @@ class PycodexCard:
                     "disabled": input_disabled,
                     "placeholder": {
                         "tag": "plain_text",
-                        "content": f"Ask {self.model_name}..." if idle else status_line,
+                        "content": self.prompt_text + (status or self.model_name),
                     },
                     "behaviors": [{"type": "callback", "value": {"action": "send"}}],
                     "value": {"action": "send"},
@@ -325,6 +319,16 @@ class PycodexCard:
             )
         return card
 
+    def earlier_turns(self):
+        if self._active_turn_id is not None:
+            return self.turn_history
+        return self.turn_history[:-1]
+
+    def show_history(self, index):
+        if type(index) is not int or not 0 <= index < len(self.earlier_turns()):
+            raise ValueError("This history turn is no longer available.")
+        self.history_index = index
+
     def parse_action(self, sdk_event) -> "typing.Dict[str, object]":
         event_data = getattr(sdk_event, "event", None)
         action_payload = getattr(event_data, "action", None)
@@ -360,6 +364,7 @@ class PycodexCard:
             self.session_key = _default_session_key(tenant_key, open_id, message_id)
         return {
             "action": action,
+            "history_index": value.get("history_index"),
             "prompt": prompt,
             "sender": self.resolve_operator_name(operator),
         }
@@ -470,10 +475,9 @@ class PycodexCard:
             )
 
     def user_access_token(self) -> "typing.Union[str, None]":
-        refresh_token = _read_refresh_token() or self.refresh_token
+        refresh_token = _read_refresh_token()
         if not refresh_token:
             return None
-        self.refresh_token = refresh_token
         now = time.time()
         if self._user_access_token and now < self._user_token_expires_at:
             return self._user_access_token
@@ -493,14 +497,12 @@ class PycodexCard:
         token = payload.get("access_token")
         if not token:
             raise RuntimeError("user access_token missing from Feishu response")
+        refresh_token = payload.get("refresh_token")
+        if refresh_token:
+            _write_refresh_token(str(refresh_token))
         self._user_access_token = str(token)
         expires_in = payload.get("expires_in") or 0
         self._user_token_expires_at = time.time() + max(60, int(expires_in) - 120)
-        refresh_token = payload.get("refresh_token")
-        if refresh_token:
-            self.refresh_token = str(refresh_token)
-            os.environ["FEISHU_REFRESH_TOKEN"] = self.refresh_token
-            _write_refresh_token(self.refresh_token)
         return self._user_access_token
 
     def tenant_access_token(self) -> str:
@@ -601,15 +603,13 @@ def _display_user_name(user: "typing.Any") -> "typing.Union[str, None]":
     return None
 
 
-def _status_template(status: str) -> "typing.Tuple[str, str]":
+def _status_color(status: str) -> str:
     normalized = status.lower()
-    if normalized in {"error", "failed"}:
-        return "red", "Session Connected"
-    if normalized in {"running", "responding", "tool", "queued", "retrying"}:
-        return "blue", "Session Connected"
-    if normalized in {"detached"}:
-        return "grey", "Session Detached"
-    return "green", "Session Connected"
+    if normalized in {"detached", "closed"}:
+        return "grey"
+    if normalized in {"idle", "idle: sleeping"}:
+        return "green"
+    return "blue"
 
 
 def _truncate(text: str, limit: int) -> str:
@@ -629,6 +629,65 @@ def _render_output_content(output: str, output_mode: str) -> str:
     return output
 
 
+def _history_panel(history, index, expanded, output_mode, interactive):
+    prompt, response = history[index]
+    content = _truncate(
+        "user> {0}\n\nassistant> {1}".format(prompt, response), CARD_OUTPUT_LIMIT
+    )
+    columns = []
+    for label, target, disabled in (
+        ("Previous", index - 1, index == 0),
+        ("Next", index + 1, index == len(history) - 1),
+    ):
+        columns.append(
+            {
+                "tag": "column",
+                "width": "auto",
+                "elements": [
+                    {
+                        "tag": "button",
+                        "text": {"tag": "plain_text", "content": label},
+                        "type": "default",
+                        "disabled": disabled or not interactive,
+                        "behaviors": [
+                            {
+                                "type": "callback",
+                                "value": {
+                                    "action": "history",
+                                    "history_index": target,
+                                },
+                            }
+                        ],
+                    }
+                ],
+            }
+        )
+    return {
+        "tag": "collapsible_panel",
+        "element_id": "history_panel",
+        "expanded": expanded,
+        "header": {
+            "icon": {
+                "tag": "standard_icon",
+                "token": "down-small-ccm_outlined",
+                "size": "16px 16px",
+            },
+            "title": {
+                "tag": "plain_text",
+                "content": "History · {0} / {1}".format(index + 1, len(history)),
+            },
+        },
+        "elements": [
+            {
+                "tag": "markdown",
+                "element_id": "history_md",
+                "content": _render_output_content(content, output_mode),
+            },
+            {"tag": "column_set", "columns": columns},
+        ],
+    }
+
+
 def _output_box(
     box_id: str,
     markdown_id: str,
@@ -664,10 +723,6 @@ def _is_card_content_error(exc: "BaseException") -> bool:
     return CARD_CONTENT_ERROR_MARKER in str(exc)
 
 
-def _escape_markdown(text: str) -> str:
-    return str(text or "").replace("`", "'")
-
-
 def _dig(value: "typing.Any", *path: str) -> "typing.Any":
     current = value
     for key in path:
@@ -700,11 +755,10 @@ def _read_refresh_token() -> "typing.Union[str, None]":
 def _write_refresh_token(value: str) -> None:
     path = _refresh_token_path()
     path.parent.mkdir(parents=True, exist_ok=True)
-    path.write_text("{0}\n".format(value), encoding="utf-8")
-    try:
+    descriptor = os.open(str(path), os.O_WRONLY | os.O_CREAT | os.O_TRUNC, 0o600)
+    with os.fdopen(descriptor, "w", encoding="utf-8") as stream:
         path.chmod(0o600)
-    except OSError:
-        pass
+        stream.write("{0}\n".format(value))
 
 
 def _api_base_to_domain(api_base: str) -> str: