langchain-agentx-python 1.0.1__tar.gz → 1.0.3__tar.gz

{langchain-agentx-python-1.0.1 → langchain-agentx-python-1.0.3}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: langchain-agentx-python
-Version: 1.0.1
+Version: 1.0.3
 Summary: LangChain/LangGraph-based agent utilities for CodeBaseX.
 Author-email: GoodMood2008 <GoodMood2008@users.noreply.github.com>
 License:                                  Apache License

{langchain-agentx-python-1.0.1 → langchain-agentx-python-1.0.3}/langchain_agentx/__init__.py

@@ -11,7 +11,7 @@ from langchain_agentx import create_loop_agent
 ```
 """
 
-__version__ = "1.0.1"
+__version__ = "1.0.3"
 
 from .loop import (  # noqa: F401
     create_loop_agent,

{langchain-agentx-python-1.0.1 → langchain-agentx-python-1.0.3}/langchain_agentx/tool_runtime/adapter.py

@@ -154,6 +154,8 @@ class LangChainAdapter:
         # 如果 loop_config 存在但 workspace_root 仍为 None，默认使用当前工作目录
         if loop_config is not None and workspace_root is None:
             workspace_root = str(Path.cwd())
+        if workspace_root is not None:
+            workspace_root = str(workspace_root)
 
         # agent_home_segment：优先从新嵌套结构获取，再回退到直接字段，再回退到旧字段
         agent_home_segment = None

{langchain-agentx-python-1.0.1 → langchain-agentx-python-1.0.3}/langchain_agentx/tool_runtime/execution/engine.py

@@ -606,11 +606,15 @@ class RuntimeToolExecutionEngine:
         override = getattr(store, "cwd_override", None)
         if not isinstance(override, str) or not override.strip():
             return
-        candidate = Path(override)
-        if candidate.is_dir():
+        from langchain_agentx.tools.bash.cwd_reporter import normalize_subprocess_cwd
+
+        normalized = normalize_subprocess_cwd(override)
+        if normalized and Path(normalized).is_dir():
+            if normalized != override and hasattr(store, "set_cwd"):
+                store.set_cwd(normalized)
             return
         if hasattr(store, "set_cwd"):
-            store.set_cwd(workspace_root)
+            store.set_cwd(str(workspace_root))
 
     def _unknown_tool_envelope(self, tool_name: str) -> ToolResultEnvelope:
         return ToolResultEnvelope(

{langchain-agentx-python-1.0.1 → langchain-agentx-python-1.0.3}/langchain_agentx/tools/bash/backend.py

@@ -46,6 +46,7 @@ from .cwd_reporter import (
     BashCwdReporter,
     bash_single_quoted,
     native_path_for_bash_redirect,
+    normalize_subprocess_cwd,
     read_cwd_file,
 )
 from .sandbox_decision import BashSandboxDecision
@@ -90,30 +91,32 @@ def extract_cwd_warning(stderr: str) -> tuple[str, str | None]:
     return cleaned_stderr, cwd_warning
 
 
-def _cwd_invalid_reason(cwd: str | None) -> str | None:
+def _cwd_invalid_reason(cwd: str | os.PathLike[str] | None) -> str | None:
     """返回 cwd 不可用于 subprocess 的原因；None 表示可用（含 cwd is None）。"""
     if cwd is None:
         return None
-    if not cwd.strip():
+    normalized = normalize_subprocess_cwd(cwd)
+    if normalized is None:
         return "empty path"
-    if not os.path.exists(cwd):
+    if not os.path.exists(normalized):
         return "does not exist"
-    if not os.path.isdir(cwd):
+    if not os.path.isdir(normalized):
         return "not a directory"
     return None
 
 
-def _pick_cwd_fallback(fallback: str | None) -> str | None:
+def _pick_cwd_fallback(fallback: str | os.PathLike[str] | None) -> str | None:
     """选择可 spawn 的回退目录（fail-closed：仅 fallback，不用进程 cwd / ~）。"""
-    if fallback and _cwd_invalid_reason(fallback) is None:
-        return os.path.realpath(fallback)
+    normalized = normalize_subprocess_cwd(fallback)
+    if normalized and _cwd_invalid_reason(normalized) is None:
+        return os.path.realpath(normalized)
     return None
 
 
 def _prepare_spawn_cwd(
-    cwd: str | None,
+    cwd: str | os.PathLike[str] | None,
     *,
-    fallback: str | None,
+    fallback: str | os.PathLike[str] | None,
 ) -> tuple[str | None, str]:
     """
     spawn 前解析 cwd：无效时 fail-closed 回退到 fallback，并生成 CC 风格 stderr 前缀。
@@ -121,9 +124,10 @@ def _prepare_spawn_cwd(
     Returns:
         (effective_cwd, stderr_prefix) — stderr_prefix 形如 ``Shell cwd was reset to ...\\n``
     """
-    reason = _cwd_invalid_reason(cwd)
+    normalized_cwd = normalize_subprocess_cwd(cwd) if cwd is not None else None
+    reason = _cwd_invalid_reason(normalized_cwd)
     if reason is None:
-        return cwd, ""
+        return normalized_cwd, ""
     reset_to = _pick_cwd_fallback(fallback)
     if reset_to is None:
         detail = f"previous cwd invalid: {cwd}: {reason}" if cwd else f"cwd invalid: {reason}"
@@ -594,11 +598,30 @@ class BashBackend:
 
     @staticmethod
     def _spawn_env_with_shell(env: dict[str, str], shell_exe: str) -> dict[str, str]:
-        """子进程 env：对齐 CC 思路，在未显式设置时注入 `SHELL`。"""
+        """子进程 env：对齐 CC 思路，在未显式设置时注入 `SHELL` / 无缓冲 Python。"""
         out = dict(env)
         out.setdefault("SHELL", shell_exe)
+        out.setdefault("PYTHONUNBUFFERED", "1")
         return out
 
+    def _sandbox_violation_message(self, request: SandboxExecutionRequest) -> str | None:
+        backend = self._sandbox_backend
+        if isinstance(backend, ConstrainedSandboxBackend):
+            return backend._violation_for_request(request)
+        return None
+
+    def _sandbox_stream_env(self, request: SandboxExecutionRequest) -> dict[str, str]:
+        backend = self._sandbox_backend
+        delegate = (
+            backend._delegate
+            if isinstance(backend, ConstrainedSandboxBackend)
+            else backend
+        )
+        if not isinstance(delegate, LocalTmpdirSandboxBackend):
+            return dict(request.env)
+        env, _temp_dir = delegate._build_env(request)
+        return env
+
     @staticmethod
     def _win32_creationflags() -> int:
         """可选隐藏控制台：`AGENTX_BASH_CREATE_NO_WINDOW=1`（默认关闭，兼容性风险见 exec-plan）。"""
@@ -1201,22 +1224,44 @@ class BashBackend:
             reason="sandbox_not_requested",
         )
         if decision.use_sandbox:
-            result = self.execute(
+            effective_cwd, reset_prefix = _prepare_spawn_cwd(cwd, fallback=fallback_cwd)
+            if effective_cwd is None and reset_prefix:
+                yield BashStreamEvent(kind="chunk", chunk=reset_prefix)
+                yield BashStreamEvent(
+                    kind="final",
+                    exit_code=126,
+                    interrupted=False,
+                    cwd_after=None,
+                )
+                return
+            if reset_prefix:
+                yield BashStreamEvent(kind="chunk", chunk=reset_prefix)
+            request = SandboxExecutionRequest(
                 command=command,
-                cwd=cwd,
+                cwd=effective_cwd,
                 timeout_sec=timeout_sec,
                 env=effective_env,
-                session_key=session_key,
-                sandbox_decision=decision,
-                fallback_cwd=fallback_cwd,
+                decision=decision,
             )
-            if result.stdout:
-                yield BashStreamEvent(kind="chunk", chunk=result.stdout)
-            yield BashStreamEvent(
-                kind="final",
-                exit_code=result.exit_code,
-                interrupted=result.interrupted,
-                cwd_after=result.cwd_after,
+            violation = self._sandbox_violation_message(request)
+            if violation is not None:
+                yield BashStreamEvent(kind="chunk", chunk=violation + "\n")
+                yield BashStreamEvent(
+                    kind="final",
+                    exit_code=126,
+                    interrupted=False,
+                    cwd_after=None,
+                )
+                return
+            stream_env = self._sandbox_stream_env(request)
+            wrapped = self._build_stream_wrapper(self._preprocess_shell_command(command))
+            yield from self._stream_execute_raw_iter(
+                wrapped_command=wrapped,
+                cwd=effective_cwd,
+                timeout_sec=timeout_sec,
+                env=stream_env,
+                cancel_event=cancel_event,
+                fallback_cwd=fallback_cwd,
             )
             return
 
@@ -1233,10 +1278,14 @@ class BashBackend:
     @staticmethod
     def _build_stream_wrapper(command: str) -> str:
         marker = "__AGENTX_STREAM_CWD__"
+        if sys.platform == "win32":
+            pwd_expr = '$(cygpath -m "$PWD" 2>/dev/null || printf %s "$PWD")'
+        else:
+            pwd_expr = '"$PWD"'
         return (
             f"{command}\n"
             "__EC=$?\n"
-            f'printf "\\n{marker}%s\\n" "$PWD"\n'
+            f'printf "\\n{marker}%s\\n" {pwd_expr}\n'
             "exit $__EC"
         )
 
@@ -1305,42 +1354,88 @@ class BashBackend:
                 )
                 return
             raise
-        selector = selectors.DefaultSelector()
         assert proc.stdout is not None
-        selector.register(proc.stdout, selectors.EVENT_READ)
-
         started = time.time()
         interrupted = False
         chunks: list[str] = []
+        stdout = proc.stdout
         try:
-            while True:
-                if cancel_event is not None and cancel_event.is_set():
-                    interrupted = True
-                    proc.kill()
-                    break
-                if time.time() - started > timeout_sec:
-                    interrupted = True
-                    proc.kill()
-                    break
-                if proc.poll() is not None and not selector.get_map():
-                    break
-                events = selector.select(timeout=0.1)
-                if not events:
-                    if proc.poll() is not None:
+            if sys.platform == "win32":
+                out_q: queue.Queue[bytes | None] = queue.Queue()
+
+                def _reader() -> None:
+                    try:
+                        while True:
+                            raw = stdout.read(4096)
+                            if not raw:
+                                break
+                            out_q.put(raw)
+                    finally:
+                        out_q.put(None)
+
+                threading.Thread(
+                    target=_reader,
+                    daemon=True,
+                    name="bash-stdout-reader",
+                ).start()
+                while True:
+                    if cancel_event is not None and cancel_event.is_set():
+                        interrupted = True
+                        proc.kill()
+                        break
+                    if time.time() - started > timeout_sec:
+                        interrupted = True
+                        proc.kill()
                         break
-                    yield BashStreamEvent(kind="tick")
-                    continue
-                for key, _ in events:
-                    raw = key.fileobj.read1(4096) if hasattr(key.fileobj, "read1") else key.fileobj.read(4096)
-                    if not raw:
-                        selector.unregister(key.fileobj)
+                    try:
+                        raw = out_q.get(timeout=0.1)
+                    except queue.Empty:
+                        if proc.poll() is not None:
+                            break
+                        yield BashStreamEvent(kind="tick")
                         continue
+                    if raw is None:
+                        break
                     text = raw.decode("utf-8", errors="replace")
                     chunks.append(text)
                     yield BashStreamEvent(kind="chunk", chunk=text)
+            else:
+                selector = selectors.DefaultSelector()
+                selector.register(stdout, selectors.EVENT_READ)
+                try:
+                    while True:
+                        if cancel_event is not None and cancel_event.is_set():
+                            interrupted = True
+                            proc.kill()
+                            break
+                        if time.time() - started > timeout_sec:
+                            interrupted = True
+                            proc.kill()
+                            break
+                        if proc.poll() is not None and not selector.get_map():
+                            break
+                        events = selector.select(timeout=0.1)
+                        if not events:
+                            if proc.poll() is not None:
+                                break
+                            yield BashStreamEvent(kind="tick")
+                            continue
+                        for key, _ in events:
+                            raw = (
+                                key.fileobj.read1(4096)
+                                if hasattr(key.fileobj, "read1")
+                                else key.fileobj.read(4096)
+                            )
+                            if not raw:
+                                selector.unregister(key.fileobj)
+                                continue
+                            text = raw.decode("utf-8", errors="replace")
+                            chunks.append(text)
+                            yield BashStreamEvent(kind="chunk", chunk=text)
+                finally:
+                    selector.close()
             proc.wait(timeout=1)
         finally:
-            selector.close()
             if proc.poll() is None:
                 proc.kill()
 
@@ -1350,7 +1445,8 @@ class BashBackend:
             before, _, after = merged.rpartition(marker)
             # 末尾的 cwd 标记不再作为 chunk 内容处理
             cleaned = before
-            cwd_after = after.strip().splitlines()[0] if after.strip() else None
+            raw_cwd = after.strip().splitlines()[0] if after.strip() else None
+            cwd_after = normalize_subprocess_cwd(raw_cwd)
             if cleaned != merged:
                 # 让上游获得去 marker 后的稳定输出
                 pass
@@ -1609,8 +1705,7 @@ def _read_fd_safe(fd: int) -> str | None:
             if not chunk:
                 break
             data += chunk
-        result = data.decode("utf-8", errors="replace").strip()
-        return result if result else None
+        return normalize_subprocess_cwd(data.decode("utf-8", errors="replace"))
     except OSError:
         return None
 
@@ -1636,7 +1731,7 @@ def _extract_cwd_from_output(raw_output: str) -> tuple[str, str | None]:
     for line in lines:
         stripped = line.rstrip("\n").rstrip("\r")
         if stripped.startswith(_CWD_SENTINEL):
-            cwd_after = stripped[len(_CWD_SENTINEL):]
+            cwd_after = normalize_subprocess_cwd(stripped[len(_CWD_SENTINEL) :])
         else:
             clean_lines.append(line)
 

{langchain-agentx-python-1.0.1 → langchain-agentx-python-1.0.3}/langchain_agentx/tools/bash/cwd_reporter.py

@@ -19,7 +19,85 @@ cwd_reporter.py — Bash 执行后 cwd 回传（Unix fd3 / Windows 临时文件
 from __future__ import annotations
 
 import os
+import re
+import subprocess
+import sys
 from pathlib import Path
+from typing import TYPE_CHECKING
+
+if TYPE_CHECKING:
+    from os import PathLike
+
+
+def posix_path_to_windows_path(posix_path: str) -> str:
+    """
+    POSIX → Windows 本机路径（对齐 CC ``posixPathToWindowsPath``）。
+
+    覆盖 Git Bash ``/c/...``、Cygwin ``/cygdrive/c/...``、UNC ``//server/share``。
+    """
+    p = posix_path.strip()
+    if not p:
+        return p
+    if p.startswith("//"):
+        return p.replace("/", "\\")
+    cyg = re.match(r"^/cygdrive/([A-Za-z])(/|$)", p)
+    if cyg:
+        letter = cyg.group(1).upper()
+        rest = p[len(f"/cygdrive/{cyg.group(1)}") :]
+        return letter + ":" + (rest or "\\").replace("/", "\\")
+    drive = re.match(r"^/([A-Za-z])(/|$)", p)
+    if drive:
+        letter = drive.group(1).upper()
+        rest = p[2:]
+        return letter + ":" + (rest or "\\").replace("/", "\\")
+    if p.startswith("/"):
+        # /tmp、/usr 等非 MSYS 盘符路径：禁止盲转 ``\tmp``（对齐 CC 仅处理盘符/UNC）
+        return p
+    return p.replace("/", "\\")
+
+
+def _cygpath_m(posix_path: str) -> str | None:
+    """MSYS ``/tmp`` 等挂载点 → 本机路径（Git Bash ``cygpath -m``）。"""
+    try:
+        proc = subprocess.run(
+            ["cygpath", "-m", posix_path],
+            capture_output=True,
+            text=True,
+            timeout=5,
+            check=False,
+        )
+    except (OSError, subprocess.TimeoutExpired):
+        return None
+    if proc.returncode != 0:
+        return None
+    out = (proc.stdout or "").strip()
+    return out or None
+
+
+def normalize_subprocess_cwd(path: str | PathLike[str] | None) -> str | None:
+    """
+    将 cwd 规范为当前平台可用于 ``subprocess`` spawn 的本机路径字符串。
+
+    Windows：把 bash ``pwd -P`` 输出的 POSIX 形态转回 ``C:\\...``；
+    Linux/macOS：仅 ``os.fspath`` + strip，不做 MSYS 转换。
+    """
+    if path is None:
+        return None
+    s = os.fspath(path).strip()
+    if not s:
+        return None
+    if sys.platform == "win32":
+        if len(s) >= 2 and s[1] == ":":
+            return os.path.normpath(s)
+        converted = posix_path_to_windows_path(s)
+        if os.path.isdir(converted):
+            return os.path.normpath(converted)
+        if s.startswith("/"):
+            via_cyg = _cygpath_m(s)
+            if via_cyg:
+                return os.path.normpath(via_cyg)
+        return os.path.normpath(converted)
+    return s
 
 
 def bash_single_quoted(s: str) -> str:
@@ -55,7 +133,7 @@ def native_path_for_bash_redirect(win_native: str) -> str:
 
 
 def read_cwd_file(native_path: str) -> str | None:
-    """读取 `pwd -P` 写入的临时文件，返回最后一行非空 cwd，失败为 None。"""
+    """读取 `pwd -P` 写入的临时文件，返回最后一行非空 cwd（本机路径），失败为 None。"""
     try:
         raw = Path(native_path).read_text(encoding="utf-8", errors="replace").strip()
     except OSError:
@@ -63,7 +141,9 @@ def read_cwd_file(native_path: str) -> str | None:
     if not raw:
         return None
     lines = [ln.strip() for ln in raw.splitlines() if ln.strip()]
-    return lines[-1] if lines else None
+    if not lines:
+        return None
+    return normalize_subprocess_cwd(lines[-1])
 
 
 class BashCwdReporter:

{langchain-agentx-python-1.0.1 → langchain-agentx-python-1.0.3}/langchain_agentx/tools/bash/tool.py

@@ -523,7 +523,9 @@ class BashRuntimeTool(RuntimeTool):
 
         # 从 state_bridge / boundary 取 cwd（跨调用持久化；含 session 中可能已失效的路径）
         cwd = self._get_current_cwd(ctx)
-        fallback_cwd = ctx.workspace_root or self._initial_cwd or cwd
+        fallback_cwd = str(
+            ctx.workspace_root or self._initial_cwd or cwd
+        )
 
         sandbox_decision = self._sandbox_decider.decide(
             command=command,
@@ -612,32 +614,20 @@ class BashRuntimeTool(RuntimeTool):
             )
 
         # ------------------------------------------------------------------
-        # 同步执行路径
+        # 同步执行路径（sandbox / 非 sandbox 均走 stream_execute_iter + 进度心跳）
         # ------------------------------------------------------------------
-        if sandbox_decision.use_sandbox:
-            accum = BashProgressAccumulator(timeout_ms=timeout_sec * 1000)
+        accum = BashProgressAccumulator(timeout_ms=timeout_sec * 1000)
 
-            def _emit_sandbox_progress(payload) -> None:
-                ctx.emit_progress(
-                    phase="running",
-                    data=bash_progress_emit_data(payload),
-                )
+        def _emit_progress(payload) -> None:
+            ctx.emit_progress(
+                phase="running",
+                data=bash_progress_emit_data(payload),
+            )
 
-            with bash_progress_heartbeat(accum, _emit_sandbox_progress):
-                result = self._backend.execute(
-                    command=command,
-                    cwd=cwd,
-                    timeout_sec=timeout_sec,
-                    sandbox_decision=sandbox_decision,
-                    fallback_cwd=fallback_cwd,
-                )
-            if result.stdout:
-                accum.append(result.stdout)
-        else:
-            final_exit_code = 0
-            final_interrupted = False
-            final_cwd_after: str | None = None
-            accum = BashProgressAccumulator(timeout_ms=timeout_sec * 1000)
+        final_exit_code = 0
+        final_interrupted = False
+        final_cwd_after: str | None = None
+        with bash_progress_heartbeat(accum, _emit_progress):
             for event in self._backend.stream_execute_iter(
                 command=command,
                 cwd=cwd,
@@ -654,18 +644,20 @@ class BashRuntimeTool(RuntimeTool):
                     final_exit_code = event.exit_code or 0
                     final_interrupted = bool(event.interrupted)
                     final_cwd_after = event.cwd_after
-            raw_stream = accum.full_stdout()
-            merged_stdout, parsed_cwd_after = _strip_stream_cwd_marker(raw_stream)
-            _, cwd_warning = extract_cwd_warning(raw_stream)
-            result = ExecuteResult(
-                stdout=merged_stdout,
-                exit_code=final_exit_code,
-                interrupted=final_interrupted,
-                cwd_after=parsed_cwd_after or final_cwd_after,
-                sandboxed=False,
-                sandbox_bypass_reason=sandbox_decision.reason,
-                cwd_warning=cwd_warning,
-            )
+        raw_stream = accum.full_stdout()
+        merged_stdout, parsed_cwd_after = _strip_stream_cwd_marker(raw_stream)
+        _, cwd_warning = extract_cwd_warning(raw_stream)
+        result = ExecuteResult(
+            stdout=merged_stdout,
+            exit_code=final_exit_code,
+            interrupted=final_interrupted,
+            cwd_after=parsed_cwd_after or final_cwd_after,
+            sandboxed=sandbox_decision.use_sandbox,
+            sandbox_bypass_reason=(
+                None if sandbox_decision.use_sandbox else sandbox_decision.reason
+            ),
+            cwd_warning=cwd_warning,
+        )
 
         spawn_cwd_was_invalid = _cwd_invalid_reason(cwd) is not None
         cwd_commit_allowed = (
@@ -721,14 +713,13 @@ class BashRuntimeTool(RuntimeTool):
             mode="foreground",
             timeout_sec=timeout_sec,
         )
-        if not sandbox_decision.use_sandbox:
-            stdout_for_trace = accum.full_stdout()
-            if stdout_for_trace:
-                ev.add(
-                    "stdout_stream",
-                    total_bytes=len(stdout_for_trace),
-                    chunk_preview=stdout_for_trace[:120],
-                )
+        stdout_for_trace = accum.full_stdout()
+        if stdout_for_trace:
+            ev.add(
+                "stdout_stream",
+                total_bytes=len(stdout_for_trace),
+                chunk_preview=stdout_for_trace[:120],
+            )
         ev.add(
             "command_completed",
             mode="foreground",
@@ -1087,10 +1078,12 @@ def _is_silent_command(command: str) -> bool:
 
 
 def _strip_stream_cwd_marker(stdout: str) -> tuple[str, str | None]:
+    from .cwd_reporter import normalize_subprocess_cwd
+
     marker = "__AGENTX_STREAM_CWD__"
     if marker not in stdout:
         return stdout, None
     before, _, after = stdout.rpartition(marker)
-    cwd = after.strip().splitlines()[0] if after.strip() else None
+    raw_cwd = after.strip().splitlines()[0] if after.strip() else None
     cleaned = before.rstrip("\n")
-    return cleaned, cwd
+    return cleaned, normalize_subprocess_cwd(raw_cwd)

{langchain-agentx-python-1.0.1 → langchain-agentx-python-1.0.3}/langchain_agentx_python.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: langchain-agentx-python
-Version: 1.0.1
+Version: 1.0.3
 Summary: LangChain/LangGraph-based agent utilities for CodeBaseX.
 Author-email: GoodMood2008 <GoodMood2008@users.noreply.github.com>
 License:                                  Apache License

{langchain-agentx-python-1.0.1 → langchain-agentx-python-1.0.3}/pyproject.toml

@@ -4,7 +4,7 @@
 
  [project]
  name = "langchain-agentx-python"
- version = "1.0.1"
+ version = "1.0.3"
  description = "LangChain/LangGraph-based agent utilities for CodeBaseX."
  readme = "README.md"
  requires-python = ">=3.11"