langchain-agentx-cli 0.2.1__tar.gz → 0.3.0__tar.gz

{langchain_agentx_cli-0.2.1 → langchain_agentx_cli-0.3.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: langchain-agentx-cli
-Version: 0.2.1
+Version: 0.3.0
 Summary: Terminal CLI/TUI for AgentX: migrate Claude Code Ink UI, backed by langchain-agentx-python SDK.
 Author: GoodMood2008
 License: Apache-2.0
@@ -22,7 +22,7 @@ Classifier: Topic :: Software Development
 Requires-Python: >=3.11
 Description-Content-Type: text/markdown
 License-File: LICENSE
-Requires-Dist: langchain-agentx-python<0.4.0,>=0.3.4
+Requires-Dist: langchain-agentx-python<0.6.0,>=0.4.3
 Requires-Dist: click>=8.1
 Requires-Dist: textual>=0.79.0
 Provides-Extra: dev

{langchain_agentx_cli-0.2.1 → langchain_agentx_cli-0.3.0}/langchain_agentx_cli/__init__.py

@@ -1,3 +1,3 @@
 """langchain_agentx_cli：依托 langchain_agentx_python SDK 的终端 CLI/TUI（CC Ink 迁移）。"""
 
-__version__ = "0.2.1"
+__version__ = "0.2.2"

{langchain_agentx_cli-0.2.1 → langchain_agentx_cli-0.3.0}/langchain_agentx_cli/app.py

@@ -10,6 +10,7 @@ app.py — Textual ReplApp 容器。
 
 from __future__ import annotations
 
+from pathlib import Path
 from typing import TYPE_CHECKING
 
 from textual import on
@@ -55,12 +56,15 @@ class ReplApp(App[None]):
             show=False,
             priority=True,
         ),
+        # 对齐 CC: Ctrl+O 切换 Transcript 模式
+        Binding("ctrl+o", "toggle_transcript", "Transcript", show=False, priority=True),
     ]
 
     def __init__(
         self,
         launch_config: ReplLaunchConfig,
         session: AgentSession | None = None,
+        debug: bool = False,
     ) -> None:
         super().__init__()
         self._launch_config = launch_config
@@ -74,6 +78,7 @@ class ReplApp(App[None]):
         self._screen_messenger = ReplScreenMessenger(self)
         # Phase 3: 加载用户偏好（供 MessageListWidget 和工具 Widget 使用）
         self.preferences: AppUserPreferences = AppPreferencesStore().load()
+        self._debug = debug
 
     @property
     def screen_messenger(self) -> ReplScreenMessenger:
@@ -92,6 +97,13 @@ class ReplApp(App[None]):
         return self._bridge
 
     def on_mount(self) -> None:
+        # DEBUG: 启用观测日志
+        if self._debug:
+            from langchain_agentx_cli.observation import observer
+
+            observer.enable(self.workspace_root)
+            observer.info("[APP] ReplApp mounted, workspace=%s", self.workspace_root)
+
         prefs = AppPreferencesStore().load()
         initial_setting = self._launch_config.theme or prefs.theme
         self.theme_manager = ThemeManager(self)
@@ -149,3 +161,21 @@ class ReplApp(App[None]):
         if self._bridge is not None:
             self._bridge.cancel_stream()
         self.exit(0)
+
+    def action_toggle_transcript(self) -> None:
+        """切换 Transcript 模式（对齐 CC Ctrl+O）。"""
+        screen = self.screen
+        if isinstance(screen, ReplScreen):
+            message_list = screen._message_list()
+            if message_list is not None:
+                from langchain_agentx_cli.observation import info
+                old_mode = message_list.display_mode
+                message_list.toggle_transcript_mode()
+                new_mode = message_list.display_mode
+                info("[APP] transcript toggled: %s → %s", old_mode, new_mode)
+
+                # 显示通知
+                if new_mode.value == "transcript":
+                    self.notify("Transcript 模式已启用（显示所有内容）", severity="information", timeout=3)
+                else:
+                    self.notify("已返回 Normal 模式", severity="information", timeout=2)

langchain_agentx_cli-0.3.0/langchain_agentx_cli/bridge/session_bridge.py

@@ -0,0 +1,465 @@
+"""
+bridge/session_bridge.py — SessionBridge（SDK 事件 → Textual Message）。
+
+职责：
+    消费 LangchainAgentEvent，经 Worker 异步调用 SDK，向 App 投递 UI Message；
+    创建权限 Queue/Resolver 并注入 AgentSession。
+
+链路位置：
+    ReplApp → SessionBridge → AgentSession.stream_loop_events
+    → LangGraphToLangchainAgentEventAdapter.adapt()；
+    权限：AgentSessionPermissionResolver ← PermissionQueueConsumer ← ConfirmQueue。
+
+当前裁剪范围：
+    不解析 LangGraph 原始事件名；Resolver 超时 300s（见 tui/permissions/config.py）。
+"""
+
+from __future__ import annotations
+
+import asyncio
+from collections.abc import Callable
+from dataclasses import dataclass, field
+from typing import TYPE_CHECKING, Any
+
+from langchain_agentx.tool_runtime.resolvers import (
+    AgentSessionPermissionResolver,
+    PermissionRequest,
+)
+from langchain_agentx_cli.observation import debug, info
+from langchain_agentx_cli.tui.permissions import (
+    PermissionQueueConsumer,
+    SessionPermissionCache,
+    inject_permission_resolver,
+)
+from langchain_agentx_cli.tui.permissions.config import DEFAULT_PERMISSION_TIMEOUT_SECONDS
+from langchain_agentx_cli.tui.permissions.dialog import DialogPermissionDecisionPort
+from langchain_agentx_cli.tui.permissions.queue import ConfirmQueue
+
+from langchain_agentx import (
+    LangGraphToLangchainAgentEventAdapter,
+    LangchainAgentEvent,
+    LangchainAgentEventType,
+)
+
+from langchain_agentx_cli.widgets.messages import (
+    AssistantMessageChunk,
+    ContextCompactedMessage,
+    ContextCompactingMessage,
+    ErrorMessageOccurred,
+    HookFinished,
+    HookStarted,
+    TaskProgress,
+    TaskStarted,
+    ThinkingContentDelta,
+    ThinkingEnded,
+    ThinkingStarted,
+    ToolUseCompleted,
+    ToolUseStarted,
+    TurnInProgress,
+    UserMessage,
+)
+
+if TYPE_CHECKING:
+    from langchain_agentx import AgentSession
+
+    from langchain_agentx_cli.app import ReplApp
+
+MVP_ADAPTER_CONFIG: dict[str, bool] = {
+    "enable_reasoning_events": True,
+    "enable_step_events": False,
+    "enable_hook_events": True,  # 启用 Hook 事件
+    "enable_compact_events": True,
+    "enable_subagent_events": True,  # Phase 3: 启用子 agent 事件
+    "synthesize_tool_call": True,
+}
+
+_LLM_FAILED_PREFIX = "[LLM request failed]"
+
+
+@dataclass
+class _TurnSegmentState:
+    """一个 compaction 段内的流式状态；在 turn 开始和 COMPACT_END 时整体重置。"""
+
+    streamed_text: bool = False
+
+    def reset(self) -> None:
+        self.streamed_text = False
+
+
+class SessionBridge:
+    """TUI 与 SDK 之间的桥接层（消费 LangchainAgentEvent）。"""
+
+    def __init__(self, app: ReplApp, session: AgentSession) -> None:
+        self._app = app
+        self._screen_messenger = app.screen_messenger
+        self._session = session
+        self._adapter = LangGraphToLangchainAgentEventAdapter(config=dict(MVP_ADAPTER_CONFIG))
+        self._current_worker: Any = None
+        self._seg = _TurnSegmentState()
+        # 对齐 CC: 集中式权限队列状态管理
+        self._permission_queue: asyncio.Queue[PermissionRequest] = asyncio.Queue()
+        self._permission_cache = SessionPermissionCache()
+        self._confirm_queue = ConfirmQueue(max_size=10)  # 对齐 CC confirmQueue
+        self._permission_resolver = AgentSessionPermissionResolver(
+            request_queue=self._permission_queue,
+            timeout=DEFAULT_PERMISSION_TIMEOUT_SECONDS,
+        )
+        inject_permission_resolver(session, self._permission_resolver)
+        self._permission_consumer = PermissionQueueConsumer(
+            queue=self._permission_queue,
+            cache=self._permission_cache,
+            confirm_queue=self._confirm_queue,  # 传入 confirm_queue
+            app=app,
+            decision_port=DialogPermissionDecisionPort(app),
+        )
+
+    def _post_ui(self, message: object) -> None:
+        self._screen_messenger.post(message)
+
+    @staticmethod
+    def _build_fallback_text(data: dict[str, Any]) -> str:
+        """为未升级的 widget 提供兜底渲染文本：summary + payload。
+
+        与 SDK envelope_to_tool_output 的语义一致（summary\\npayload），
+        让仍按 event.output 字符串渲染的 widget 不需要改动即可工作。
+        """
+        summary = str(data.get("summary", ""))
+        payload = data.get("payload")
+        if payload is None or payload == "":
+            return summary
+        if isinstance(payload, str):
+            payload_str = payload
+        else:
+            import json
+            try:
+                payload_str = json.dumps(payload, ensure_ascii=False)
+            except (TypeError, ValueError):
+                payload_str = str(payload)
+        return f"{summary}\n{payload_str}" if summary else payload_str
+
+    def submit_input(self, text: str) -> None:
+        self._post_ui(UserMessage(content=text))
+        self._post_ui(TurnInProgress(in_progress=True))
+        self._current_worker = self._app.run_worker(
+            self._stream_turn(text),
+            name="sdk-stream",
+            exit_on_error=False,
+        )
+
+    async def _stream_turn(self, user_input: str) -> None:
+        self._adapter._reset_state()
+        self._seg.reset()
+        raw_events = self._session.stream_loop_events(user_input)
+        try:
+            async for event in self._adapter.adapt(raw_events):
+                self._dispatch_event(event)
+        except (KeyboardInterrupt, SystemExit):
+            raise
+        except Exception as exc:
+            debug("stream_turn error", exc_info=True)
+            self._post_ui(ErrorMessageOccurred(error=str(exc)))
+        finally:
+            self._post_ui(TurnInProgress(in_progress=False))
+            self._current_worker = None
+
+    def _dispatch_event(self, event: LangchainAgentEvent) -> None:
+        data = event.data or {}
+        # DEBUG: 追踪所有事件
+        info(
+            "[BRIDGE] event=%s data_keys=%s",
+            event.event_type,
+            list(data.keys()) if data else [],
+        )
+        match event.event_type:
+            case LangchainAgentEventType.TEXT_START:
+                self._post_ui(
+                    AssistantMessageChunk(delta="", is_complete=False)
+                )
+            case LangchainAgentEventType.TEXT_DELTA:
+                delta = str(data.get("text", ""))
+                info("[BRIDGE] TEXT_DELTA len=%d first50=%r", len(delta), delta[:50])
+                if delta:
+                    self._seg.streamed_text = True
+                self._post_ui(
+                    AssistantMessageChunk(
+                        delta=delta,
+                        is_complete=False,
+                    )
+                )
+            case LangchainAgentEventType.TEXT_END:
+                info("[BRIDGE] TEXT_END — finalizing assistant")
+                self._post_ui(
+                    AssistantMessageChunk(delta="", is_complete=True)
+                )
+            case LangchainAgentEventType.TOOL_INPUT:
+                tool_input = data.get("input")
+                tool_name = str(data.get("tool_name", ""))
+                if not isinstance(tool_input, dict):
+                    tool_input = data.get("params") if isinstance(data.get("params"), dict) else {}
+                info("[BRIDGE] TOOL_INPUT tool_name=%s", tool_name)
+                self._post_ui(
+                    ToolUseStarted(
+                        tool_name=tool_name,
+                        tool_input=tool_input,
+                    )
+                )
+            case LangchainAgentEventType.TOOL_CALL:
+                tool_name = str(data.get("tool_name", ""))
+                info("[BRIDGE] TOOL_CALL tool_name=%s", tool_name)
+                pass
+            case LangchainAgentEventType.TOOL_RESULT:
+                tool_name = str(data.get("tool_name", ""))
+                fallback_output = self._build_fallback_text(data)
+                info(
+                    "[BRIDGE] TOOL_RESULT tool_name=%s summary_len=%d payload_type=%s has_display=%s",
+                    tool_name,
+                    len(str(data.get("summary", ""))),
+                    type(data.get("payload")).__name__,
+                    bool(data.get("display")),
+                )
+                self._post_ui(
+                    ToolUseCompleted(
+                        tool_name=tool_name,
+                        output=fallback_output,
+                        summary=str(data.get("summary", "")),
+                        payload=data.get("payload"),
+                        status=str(data.get("status", "ok")),
+                        meta=data.get("meta") if isinstance(data.get("meta"), dict) else None,
+                        display=data.get("display") if isinstance(data.get("display"), dict) else None,
+                        truncated=bool(data.get("truncated", False)),
+                        overflow_file=data.get("overflow_file"),
+                    )
+                )
+            case LangchainAgentEventType.TOOL_ERROR:
+                tool_name = str(data.get("tool_name", ""))
+                error_text = str(data.get("error", ""))
+                self._post_ui(
+                    ToolUseCompleted(
+                        tool_name=tool_name,
+                        output=f"Error: {error_text}",
+                        error=error_text or None,
+                        summary=str(data.get("summary", "")),
+                        payload=data.get("payload"),
+                        status=str(data.get("status", "error")),
+                        meta=data.get("meta") if isinstance(data.get("meta"), dict) else None,
+                        display=data.get("display") if isinstance(data.get("display"), dict) else None,
+                    )
+                )
+            case LangchainAgentEventType.ERROR:
+                self._post_ui(
+                    ErrorMessageOccurred(
+                        error=str(data.get("error", "Unknown error")),
+                    )
+                )
+            case LangchainAgentEventType.REASONING_START:
+                self._post_ui(ThinkingStarted())
+            case LangchainAgentEventType.REASONING_DELTA:
+                delta = str(data.get("text", ""))
+                if delta:
+                    self._post_ui(ThinkingContentDelta(delta=delta))
+            case LangchainAgentEventType.REASONING_END:
+                self._post_ui(ThinkingEnded())
+            case LangchainAgentEventType.START:
+                self._post_ui(TurnInProgress(in_progress=True))
+            case LangchainAgentEventType.FINISH:
+                self._emit_finish_answer(str(data.get("answer", "")))
+                self._post_ui(TurnInProgress(in_progress=False))
+            case LangchainAgentEventType.COMPACT_END:
+                self._seg.reset()
+                compact_type = data.get("compact_type", "autocompact")  # 向后兼容
+                tokens_freed = data.get("tokens_freed") or 0
+                info("[BRIDGE] COMPACT_END type=%s tokens=%s", compact_type, tokens_freed)
+                # 只显示 autocompact（LLM 摘要），忽略 microcompact（工具清理）
+                if compact_type == "autocompact":
+                    self._post_ui(ContextCompactedMessage())
+            case LangchainAgentEventType.COMPACT_START:
+                info("[BRIDGE] COMPACT_START — compacting...")
+                pass
+            # Phase 3: 子 agent 工具事件（通过 adispatch_custom_event 冒泡）
+            case LangchainAgentEventType.SUBAGENT_TOOL_CALL:
+                tool_name = str(data.get("tool_name", ""))
+                tool_input = data.get("tool_input")
+                parent_tool_use_id = data.get("parent_tool_use_id")
+                info(
+                    "[BRIDGE] SUBAGENT_TOOL_CALL tool=%s parent=%s",
+                    tool_name,
+                    parent_tool_use_id,
+                )
+                self._post_ui(
+                    ToolUseStarted(
+                        tool_name=tool_name,
+                        tool_input=tool_input if isinstance(tool_input, dict) else {},
+                        parent_tool_use_id=parent_tool_use_id,
+                    )
+                )
+            case LangchainAgentEventType.SUBAGENT_TOOL_RESULT:
+                tool_name = str(data.get("tool_name", ""))
+                parent_tool_use_id = data.get("parent_tool_use_id")
+                fallback_output = self._build_fallback_text(data)
+                info(
+                    "[BRIDGE] SUBAGENT_TOOL_RESULT tool=%s parent=%s summary_len=%d",
+                    tool_name,
+                    parent_tool_use_id,
+                    len(str(data.get("summary", ""))),
+                )
+                self._post_ui(
+                    ToolUseCompleted(
+                        tool_name=tool_name,
+                        output=fallback_output,
+                        summary=str(data.get("summary", "")),
+                        payload=data.get("payload"),
+                        status=str(data.get("status", "ok")),
+                        meta=data.get("meta") if isinstance(data.get("meta"), dict) else None,
+                        display=data.get("display") if isinstance(data.get("display"), dict) else None,
+                        truncated=bool(data.get("truncated", False)),
+                        overflow_file=data.get("overflow_file"),
+                        parent_tool_use_id=parent_tool_use_id,
+                    )
+                )
+            case LangchainAgentEventType.HOOK_STARTED:
+                hook_event = str(data.get("hook_event", ""))
+                hook_name = str(data.get("hook_name", ""))
+                info("[BRIDGE] HOOK_STARTED event=%s name=%s", hook_event, hook_name)
+                self._post_ui(
+                    HookStarted(
+                        hook_event=hook_event,
+                        hook_name=hook_name,
+                    )
+                )
+            case LangchainAgentEventType.HOOK_FINISHED:
+                hook_event = str(data.get("hook_event", ""))
+                hook_name = str(data.get("hook_name", ""))
+                outcome = str(data.get("outcome", ""))
+                info(
+                    "[BRIDGE] HOOK_FINISHED event=%s name=%s outcome=%s stdout_len=%d stderr_len=%d",
+                    hook_event,
+                    hook_name,
+                    outcome,
+                    len(str(data.get("combined_stdout", ""))),
+                    len(str(data.get("combined_stderr", ""))),
+                )
+                self._post_ui(
+                    HookFinished(
+                        hook_event=hook_event,
+                        hook_name=hook_name,
+                        outcome=outcome,
+                        stdout=data.get("combined_stdout"),
+                        stderr=data.get("combined_stderr"),
+                        exit_codes=data.get("exit_codes"),
+                        combined_stdout=data.get("combined_stdout"),
+                        combined_stderr=data.get("combined_stderr"),
+                    )
+                )
+            case LangchainAgentEventType.TASK_STARTED:
+                task_id = str(data.get("task_id", ""))
+                task_type = str(data.get("task_type", ""))
+                description = str(data.get("description", ""))
+                tool_use_id = data.get("tool_use_id")
+                info("[BRIDGE] TASK_STARTED id=%s type=%s", task_id, task_type)
+                self._post_ui(
+                    TaskStarted(
+                        task_id=task_id,
+                        task_type=task_type,
+                        description=description,
+                        tool_use_id=tool_use_id,
+                        prompt=data.get("prompt"),
+                        workflow_name=data.get("workflow_name"),
+                    )
+                )
+            case LangchainAgentEventType.TASK_PROGRESS:
+                task_id = str(data.get("task_id", ""))
+                description = str(data.get("description", ""))
+                usage = data.get("usage")
+                last_tool_name = data.get("last_tool_name")
+                summary = data.get("summary")
+                info("[BRIDGE] TASK_PROGRESS id=%s summary=%s", task_id, summary)
+                self._post_ui(
+                    TaskProgress(
+                        task_id=task_id,
+                        description=description,
+                        usage=usage if isinstance(usage, dict) else None,
+                        last_tool_name=last_tool_name,
+                        summary=summary,
+                        tool_use_id=data.get("tool_use_id"),
+                    )
+                )
+            case _:
+                pass
+
+    def _emit_finish_answer(self, answer: str) -> None:
+        """非流式路径（如 API 失败合成 AIMessage）在 FINISH.answer 带回文案。"""
+        text = answer.strip()
+        if not text:
+            return
+        if text.startswith(_LLM_FAILED_PREFIX):
+            self._post_ui(ErrorMessageOccurred(error=text))
+            return
+        if not self._seg.streamed_text:
+            self._post_ui(
+                AssistantMessageChunk(delta=text, is_complete=True)
+            )
+
+    def is_streaming(self) -> bool:
+        return self._current_worker is not None
+
+    def is_session_ready(self) -> bool:
+        return self._session is not None and getattr(self._session, "_graph", None) is not None
+
+    @property
+    def session(self) -> AgentSession:
+        return self._session
+
+    @property
+    def permission_queue(self) -> asyncio.Queue[PermissionRequest]:
+        return self._permission_queue
+
+    @property
+    def permission_cache(self) -> SessionPermissionCache:
+        return self._permission_cache
+
+    @property
+    def confirm_queue(self) -> ConfirmQueue:
+        """对齐 CC: confirmQueue 状态访问。"""
+        return self._confirm_queue
+
+    @property
+    def permission_resolver(self) -> AgentSessionPermissionResolver:
+        return self._permission_resolver
+
+    @property
+    def permission_consumer(self) -> PermissionQueueConsumer:
+        return self._permission_consumer
+
+    async def dispatch_command(
+        self,
+        raw_input: str,
+        *,
+        output: Callable[[str], None] | None = None,
+    ) -> str | None:
+        if not self.is_session_ready():
+            message = "错误：会话未建立，无法执行该命令"
+            if output is not None:
+                output(message)
+            return message
+        result = await self._session.dispatch_command(raw_input)
+        if result is None:
+            return None
+        if result.error:
+            message = str(result.error)
+            if output is not None:
+                output(message)
+            return message
+        if result.output:
+            message = str(result.output)
+            if output is not None:
+                output(message)
+            return message
+        return None
+
+    def cancel_stream(self) -> None:
+        if self._current_worker is not None:
+            cancel = getattr(self._current_worker, "cancel", None)
+            if callable(cancel):
+                cancel()
+            self._current_worker = None
+            self._post_ui(TurnInProgress(in_progress=False))

{langchain_agentx_cli-0.2.1 → langchain_agentx_cli-0.3.0}/langchain_agentx_cli/cli.py

@@ -50,6 +50,7 @@ class CliEntry:
         show_config: bool,
         enable_git_snapshot: bool | None,
         skip_permissions: bool = False,
+        debug: bool = False,
     ) -> int:
         # Mode 到 agent_home 的映射（优先级高于 --agent-home）
         if mode:
@@ -88,7 +89,7 @@ class CliEntry:
             return 2
 
         try:
-            return self._run_tui(launch_config, session)
+            return self._run_tui(launch_config, session, debug=debug)
         finally:
             asyncio.run(close_agent_session(session))
 
@@ -138,8 +139,10 @@ class CliEntry:
         }
         return mode_map.get(mode.lower(), ".langchain_agentx")
 
-    def _run_tui(self, launch_config: ReplLaunchConfig, session) -> int:  # noqa: ANN001
-        app = ReplApp(launch_config=launch_config, session=session)
+    def _run_tui(
+        self, launch_config: ReplLaunchConfig, session, debug: bool = False  # noqa: ANN001
+    ) -> int:
+        app = ReplApp(launch_config=launch_config, session=session, debug=debug)
         app.run()
         return 0
 
@@ -203,6 +206,13 @@ _CONFIG_PATH = user_config_path()
     default=False,
     help="跳过工具权限确认（对齐 CC --dangerously-skip-permissions）",
 )
+@click.option(
+    "--debug",
+    "-d",
+    is_flag=True,
+    default=False,
+    help="启用观察日志（写入 workspace/log/agentx-{pid}.log）",
+)
 def main(
     workspace_root: Path | None,
     mode: str | None,
@@ -212,6 +222,7 @@ def main(
     show_config: bool,
     enable_git_snapshot: bool | None,
     skip_permissions: bool,
+    debug: bool,
 ) -> None:
     """langchain-agentx 终端 REPL（MVP）。"""
     code = CliEntry().run(
@@ -223,5 +234,6 @@ def main(
         show_config=show_config,
         enable_git_snapshot=enable_git_snapshot,
         skip_permissions=skip_permissions,
+        debug=debug,
     )
     raise SystemExit(code)

langchain_agentx_cli-0.3.0/langchain_agentx_cli/observation/__init__.py

@@ -0,0 +1,44 @@
+"""
+observation — 统一日志观测模块。
+
+提供启用/禁用控制的日志接口，默认禁用（零开销）。
+
+使用方式：
+    from langchain_agentx_cli.observation import observer, info
+
+    # 模块直接调用
+    info("[MODULE] some_event value=%s", value)
+
+    # 或使用 observer 实例
+    observer.info("[MODULE] some_event value=%s", value)
+"""
+
+from langchain_agentx_cli.observation.observer import (
+    Observer,
+    critical,
+    debug,
+    disable,
+    enable,
+    error,
+    get_observer,
+    info,
+    is_enabled,
+    warning,
+)
+
+# 全局 observer 实例（常用别名）
+observer = get_observer()
+
+__all__ = [
+    "Observer",
+    "observer",
+    "get_observer",
+    "enable",
+    "disable",
+    "is_enabled",
+    "debug",
+    "info",
+    "warning",
+    "error",
+    "critical",
+]

langchain_agentx_cli-0.3.0/langchain_agentx_cli/observation/config.py

@@ -0,0 +1,35 @@
+"""
+observation/config.py — 日志配置常量。
+"""
+
+from __future__ import annotations
+
+import os
+from pathlib import Path
+
+# 日志文件名模板
+LOG_FILENAME_TEMPLATE = "agentx-{pid}.log"
+
+# 默认日志格式
+LOG_FORMAT = "%(asctime)s %(name)s %(levelname)s %(message)s"
+LOG_DATE_FORMAT = "%Y-%m-%d %H:%M:%S"
+
+# 默认日志级别
+DEFAULT_LOG_LEVEL = "INFO"
+
+# 日志目录名（相对 workspace root）
+LOG_DIR_NAME = "log"
+
+
+def get_log_dir(workspace_root: Path | None) -> Path:
+    """获取日志目录路径。"""
+    if workspace_root:
+        return workspace_root / LOG_DIR_NAME
+    # 回退到临时目录（无 workspace 时）
+    return Path(os.getenv("TMPDIR", "/tmp")) / "agentx-logs"
+
+
+def get_log_path(workspace_root: Path | None) -> Path:
+    """获取日志文件完整路径。"""
+    log_dir = get_log_dir(workspace_root)
+    return log_dir / LOG_FILENAME_TEMPLATE.format(pid=os.getpid())