langchain-agentcore-codeinterpreter 0.0.3__tar.gz → 0.0.5__tar.gz

{langchain_agentcore_codeinterpreter-0.0.3 → langchain_agentcore_codeinterpreter-0.0.5}/Makefile

@@ -30,10 +30,10 @@ test:  ## Run individual unit test: make test TEST_FILE=tests/unit_tests/test.py
 	env -u AWS_ACCESS_KEY_ID -u AWS_SECRET_ACCESS_KEY -u AWS_SESSION_TOKEN uv run --group test pytest --disable-socket --allow-unix-socket $(TEST_FILE)
 
 integration_tests: ## Run all integration tests
-	uv run --group test --group test_integration pytest -n auto $(TEST_FILE)
+	uv run --group test --group test_integration pytest -n auto --benchmark-disable $(TEST_FILE)
 
 integration_test: ## Run individual integration test: make integration_test TEST_FILE=tests/integration_tests/integ_test.py
-	uv run --group test --group test_integration pytest -n auto $(TEST_FILE)
+	uv run --group test --group test_integration pytest -n auto --benchmark-disable $(TEST_FILE)
 
 coverage_tests: ## Run unit tests with coverage
 	env -u AWS_ACCESS_KEY_ID -u AWS_SECRET_ACCESS_KEY -u AWS_SESSION_TOKEN uv run --group test pytest --cov=langchain_agentcore_codeinterpreter --cov-report=html --cov-report=term-missing --cov-branch tests/unit_tests/

{langchain_agentcore_codeinterpreter-0.0.3 → langchain_agentcore_codeinterpreter-0.0.5}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: langchain-agentcore-codeinterpreter
-Version: 0.0.3
+Version: 0.0.5
 Summary: Amazon Bedrock AgentCore Code Interpreter sandbox integration for Deep Agents
 Project-URL: Source Code, https://github.com/langchain-ai/langchain-aws/tree/main/libs/agentcore-codeinterpreter
 Project-URL: Repository, https://github.com/langchain-ai/langchain-aws

{langchain_agentcore_codeinterpreter-0.0.3 → langchain_agentcore_codeinterpreter-0.0.5}/langchain_agentcore_codeinterpreter/sandbox.py

@@ -14,6 +14,9 @@ from deepagents.backends.protocol import (
     ExecuteResponse,
     FileDownloadResponse,
     FileUploadResponse,
+    GlobResult,
+    GrepResult,
+    LsResult,
     ReadResult,
     WriteResult,
 )
@@ -167,6 +170,15 @@ class AgentCoreSandbox(BaseSandbox):
     The caller is responsible for managing the interpreter lifecycle
     (``start()`` / ``stop()``).
 
+    !!! note
+
+        When the sandbox working directory is not ``/`` (e.g.
+        ``/opt/amazon/genesis1p-tools/var/``), paths must be resolved
+        against the real cwd before shell preflight commands and stripped of
+        the cwd prefix before the AgentCore ``writeFiles``/``readFiles`` APIs.
+        Pass the known cwd via the ``cwd`` constructor argument, or let the
+        sandbox detect it automatically on the first path operation via ``pwd``.
+
     Example:
         .. code-block:: python
 
@@ -185,26 +197,114 @@ class AgentCoreSandbox(BaseSandbox):
             interpreter.stop()
     """
 
-    def __init__(self, *, interpreter: CodeInterpreter) -> None:
+    def __init__(
+        self,
+        *,
+        interpreter: CodeInterpreter,
+        cwd: str | None = None,
+    ) -> None:
         """Create a backend wrapping an active CodeInterpreter session.
 
         Args:
             interpreter: A started :class:`CodeInterpreter` instance.
+            cwd: The sandbox working directory (e.g.
+                ``"/opt/amazon/genesis1p-tools/var"``). When provided,
+                ``write()`` uses it to resolve virtual paths to real absolute
+                paths and to strip the prefix before the AgentCore
+                ``writeFiles`` API. When omitted, the cwd is detected
+                automatically on the first path operation via ``pwd``.
         """
         self._interpreter = interpreter
+        self._cwd: str | None = cwd.rstrip("/") if cwd is not None else None
+
+    def _get_cwd(self) -> str:
+        """Return the sandbox working directory, detecting it lazily if needed.
+
+        Returns:
+            The working directory with any trailing slash stripped.
+        """
+        if self._cwd is None:
+            result = self.execute("pwd")
+            if result.exit_code != 0 or not result.output.strip():
+                raise RuntimeError(
+                    f"Failed to detect sandbox working directory: "
+                    f"exit_code={result.exit_code}, output={result.output!r}"
+                )
+            self._cwd = result.output.strip().rstrip("/")
+        return self._cwd
+
+    def _to_relative_path(self, path: str) -> str:
+        """Strip the cwd prefix (or leading slashes) for AgentCore file APIs.
 
-    @staticmethod
-    def _to_relative_path(path: str) -> str:
-        """Strip leading slashes and ``./`` prefixes for AgentCore APIs.
+        When the sandbox cwd is known and ``path`` starts with it, the cwd
+        prefix is removed so the AgentCore ``writeFiles``/``readFiles`` APIs
+        receive a cwd-relative path. For paths that do not start with the cwd,
+        the standard leading-slash stripping is applied.
 
         Args:
             path: File path (absolute or relative).
 
         Returns:
-            Relative path string.
+            Path relative to the sandbox cwd, with no leading ``/`` or ``./``.
         """
+        if self._cwd is not None:
+            cwd_prefix = self._cwd + "/"
+            if path.startswith(cwd_prefix):
+                return path[len(cwd_prefix) :]
         return _normalize_relative_path(path)
 
+    def _to_absolute_path(self, path: str) -> str:
+        """Resolve a path to a real absolute path under the sandbox cwd.
+
+        Paths already under the cwd are returned unchanged. Virtual paths
+        (e.g. ``/workspace/hello.py``) and relative paths are prepended with
+        the cwd so that shell commands (``makedirs``, etc.) operate on the
+        real filesystem location.
+
+        Args:
+            path: File path to resolve.
+
+        Returns:
+            Absolute path under the sandbox cwd.
+        """
+        cwd = self._get_cwd()
+        if not cwd:
+            return path
+        if path.startswith(cwd + "/") or path == cwd:
+            return path
+        return cwd + "/" + path.lstrip("/")
+
+    def write(self, file_path: str, content: str) -> WriteResult:
+        """Create a new file in the sandbox, failing if it already exists.
+
+        Normalizes ``file_path`` to a real absolute path under the sandbox cwd
+        before the preflight shell command (so ``makedirs`` operates on the
+        correct location) and before uploading (so the AgentCore ``writeFiles``
+        API receives a cwd-relative path rather than a doubled absolute path).
+
+        Args:
+            file_path: Destination path for the new file. May be a real
+                absolute path under the sandbox cwd, a virtual absolute path
+                (e.g. ``/workspace/hello.py``), or a relative path.
+            content: UTF-8 text content to write.
+
+        Returns:
+            ``WriteResult`` with ``path`` set to the resolved absolute path on
+            success, or ``error`` on failure.
+        """
+        abs_path = self._to_absolute_path(file_path)
+        preflight_error = self._write_preflight(abs_path)
+        if preflight_error is not None:
+            return preflight_error
+        responses = self.upload_files([(abs_path, content.encode("utf-8"))])
+        assert responses, "upload_files returned no responses"
+        response = responses[0]
+        if response.error:
+            return WriteResult(
+                error=f"Failed to write file '{abs_path}': {response.error}"
+            )
+        return WriteResult(path=abs_path)
+
     def _invoke(self, method: str, params: dict[str, Any]) -> dict[str, Any]:
         """Invoke the interpreter and eagerly consume the response stream.
 
@@ -311,19 +411,20 @@ class AgentCoreSandbox(BaseSandbox):
             as the input paths.
         """
         try:
+            self._get_cwd()
             relative_paths = [self._to_relative_path(p) for p in paths]
             response = self._invoke(
                 method="readFiles", params={"paths": relative_paths}
             )
-            file_contents = _extract_files_from_stream(response, paths)
+            file_contents = _extract_files_from_stream(response, relative_paths)
 
             return [
                 FileDownloadResponse(
-                    path=path,
-                    content=file_contents.get(path),
-                    error=None if path in file_contents else "file_not_found",
+                    path=original,
+                    content=file_contents.get(rel),
+                    error=None if rel in file_contents else "file_not_found",
                 )
-                for path in paths
+                for original, rel in zip(paths, relative_paths)
             ]
         except SessionExpiredError:
             logger.error("AgentCore session expired while downloading files: %s", paths)
@@ -341,7 +442,7 @@ class AgentCoreSandbox(BaseSandbox):
     def upload_files(self, files: list[tuple[str, bytes]]) -> list[FileUploadResponse]:
         """Upload files to the AgentCore sandbox.
 
-        Text files are sent directly; binary files are base64-encoded.
+        Text files are sent directly; binary files are sent as raw blobs.
 
         Args:
             files: List of ``(path, content)`` tuples to upload.
@@ -350,7 +451,7 @@ class AgentCoreSandbox(BaseSandbox):
             List of :class:`FileUploadResponse` objects in the same order
             as the input files.
         """
-        file_list: list[dict[str, str]] = []
+        file_list: list[dict[str, str | bytes]] = []
 
         for path, content in files:
             rel_path = self._to_relative_path(path)
@@ -358,8 +459,7 @@ class AgentCoreSandbox(BaseSandbox):
                 text_content = content.decode("utf-8")
                 file_list.append({"path": rel_path, "text": text_content})
             except UnicodeDecodeError:
-                encoded = base64.b64encode(content).decode("ascii")
-                file_list.append({"path": rel_path, "blob": encoded})
+                file_list.append({"path": rel_path, "blob": content})
 
         try:
             if file_list:
@@ -381,6 +481,53 @@ class AgentCoreSandbox(BaseSandbox):
                 for path, _ in files
             ]
 
+    def ls(self, path: str) -> LsResult:
+        """List a directory, resolving ``path`` against the sandbox cwd."""
+        return super().ls(self._to_absolute_path(path))
+
+    def read(
+        self,
+        file_path: str,
+        offset: int = 0,
+        limit: int = 2000,
+    ) -> ReadResult:
+        """Read a file, resolving ``file_path`` against the sandbox cwd."""
+        return super().read(self._to_absolute_path(file_path), offset, limit)
+
+    def grep(
+        self,
+        pattern: str,
+        path: str | None = None,
+        glob: str | None = None,
+    ) -> GrepResult:
+        """Search file contents, resolving ``path`` against the sandbox cwd."""
+        resolved = self._to_absolute_path(path) if path else path
+        return super().grep(pattern, resolved, glob)
+
+    def glob(
+        self,
+        pattern: str,
+        path: str | None = None,
+    ) -> GlobResult:
+        """Match paths by glob, resolving ``path`` against the sandbox cwd."""
+        resolved = self._to_absolute_path(path) if path else path
+        return super().glob(pattern, resolved)
+
+    def edit(
+        self,
+        file_path: str,
+        old_string: str,
+        new_string: str,
+        replace_all: bool = False,  # noqa: FBT001, FBT002
+    ) -> EditResult:
+        """Edit a file, resolving ``file_path`` against the sandbox cwd."""
+        return super().edit(
+            self._to_absolute_path(file_path),
+            old_string,
+            new_string,
+            replace_all,
+        )
+
     # ------------------------------------------------------------------
     # Async overrides — use a dedicated executor to avoid starving the
     # default asyncio thread pool with long-running boto3 stream reads.
@@ -520,3 +667,63 @@ class AgentCoreSandbox(BaseSandbox):
             _AGENTCORE_EXECUTOR,
             lambda: self.download_files(paths),
         )
+
+    async def als(self, path: str) -> LsResult:
+        """Async version of :meth:`ls`.
+
+        Args:
+            path: Directory path to list, resolved against the sandbox cwd.
+
+        Returns:
+            ``LsResult`` with directory entries on success or ``error`` on
+            failure.
+        """
+        loop = asyncio.get_running_loop()
+        return await loop.run_in_executor(
+            _AGENTCORE_EXECUTOR,
+            lambda: self.ls(path),
+        )
+
+    async def agrep(
+        self,
+        pattern: str,
+        path: str | None = None,
+        glob: str | None = None,
+    ) -> GrepResult:
+        """Async version of :meth:`grep`.
+
+        Args:
+            pattern: Literal string to search for.
+            path: Directory or file to search in, resolved against the sandbox
+                cwd. When ``None``, the ``BaseSandbox`` default is used.
+            glob: Optional file-name glob to restrict the search.
+
+        Returns:
+            ``GrepResult`` with a list of matches or ``error`` on failure.
+        """
+        loop = asyncio.get_running_loop()
+        return await loop.run_in_executor(
+            _AGENTCORE_EXECUTOR,
+            lambda: self.grep(pattern, path, glob),
+        )
+
+    async def aglob(
+        self,
+        pattern: str,
+        path: str | None = None,
+    ) -> GlobResult:
+        """Async version of :meth:`glob`.
+
+        Args:
+            pattern: Glob pattern to match.
+            path: Directory to search in, resolved against the sandbox cwd.
+                When ``None``, the ``BaseSandbox`` default is used.
+
+        Returns:
+            ``GlobResult`` with a list of matches or ``error`` on failure.
+        """
+        loop = asyncio.get_running_loop()
+        return await loop.run_in_executor(
+            _AGENTCORE_EXECUTOR,
+            lambda: self.glob(pattern, path),
+        )

{langchain_agentcore_codeinterpreter-0.0.3 → langchain_agentcore_codeinterpreter-0.0.5}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "hatchling.build"
 
 [project]
 name = "langchain-agentcore-codeinterpreter"
-version = "0.0.3"
+version = "0.0.5"
 description = "Amazon Bedrock AgentCore Code Interpreter sandbox integration for Deep Agents"
 readme = "README.md"
 license = "MIT"
@@ -46,7 +46,7 @@ dev = [
 ]
 
 [tool.uv]
-prerelease = "allow"
+prerelease = "if-necessary-or-explicit"
 
 [tool.ruff.lint]
 select = [
@@ -62,6 +62,12 @@ disallow_untyped_defs = "True"
 
 [tool.pytest.ini_options]
 addopts = "--strict-markers --strict-config --durations=5"
+filterwarnings = [
+    # `bedrock-agentcore` (third-party) still uses class-based pydantic `Config`
+    # in `bedrock_agentcore.runtime.context.RequestContext`. Remove once upstream
+    # migrates to `ConfigDict`.
+    "ignore:Support for class-based .config. is deprecated:DeprecationWarning",
+]
 markers = [
     "requires: mark tests as requiring a specific library",
     "asyncio: mark tests as requiring asyncio",

{langchain_agentcore_codeinterpreter-0.0.3 → langchain_agentcore_codeinterpreter-0.0.5}/tests/integration_tests/sandbox/test_sandbox.py

@@ -82,20 +82,50 @@ class TestAgentCoreSandboxIntegration:
         assert results[0].error is not None
 
     def test_binary_roundtrip(self, sandbox: AgentCoreSandbox) -> None:
-        """Binary content uploaded via base64 may be returned as base64 text."""
-        import base64
-
+        """Binary content uploaded as a blob should round-trip unchanged."""
         content = b"\x00\x01\x02\xff\xfe\xfd"
         sandbox.upload_files([("binary_test.bin", content)])
         results = sandbox.download_files(["binary_test.bin"])
         assert results[0].error is None
-        # AgentCore returns blob uploads as text containing the base64 string
-        assert results[0].content in (content, base64.b64encode(content))
+        assert results[0].content == content
 
     def test_session_id(self, sandbox: AgentCoreSandbox) -> None:
         """The sandbox should have a non-empty session ID."""
         assert sandbox.id != ""
 
+    def test_read_plane_roundtrip_virtual_path(self, sandbox: AgentCoreSandbox) -> None:
+        """Read plane round-trips a virtual path against a non-root cwd."""
+        vpath = "/workspace/readplane_roundtrip.txt"
+        vdir = "/workspace"
+        content = "needle in haystack\nsecond line\n"
+
+        write_result = sandbox.write(vpath, content)
+        assert write_result.error is None, write_result.error
+
+        read_result = sandbox.read(vpath)
+        assert read_result.error is None, read_result.error
+        assert read_result.file_data is not None
+        assert read_result.file_data["content"].strip() == content.strip()
+
+        ls_result = sandbox.ls(vdir)
+        assert ls_result.error is None, ls_result.error
+        assert ls_result.entries is not None
+        assert any("readplane_roundtrip.txt" in e["path"] for e in ls_result.entries)
+
+        grep_result = sandbox.grep("needle", vdir)
+        assert grep_result.error is None, grep_result.error
+        assert grep_result.matches
+
+        glob_result = sandbox.glob("*.txt", vdir)
+        assert glob_result.error is None, glob_result.error
+        assert glob_result.matches
+
+        edit_result = sandbox.edit(vpath, "needle", "pin")
+        assert edit_result.error is None, edit_result.error
+        after = sandbox.read(vpath)
+        assert after.file_data is not None
+        assert "pin in haystack" in after.file_data["content"]
+
     # ------------------------------------------------------------------
     # Async integration tests
     # ------------------------------------------------------------------
@@ -135,3 +165,28 @@ class TestAgentCoreSandboxIntegration:
         for i, result in enumerate(results):
             assert result.exit_code == 0
             assert f"concurrent-{i}" in result.output
+
+    def test_aread_plane_roundtrip_virtual_path(
+        self, sandbox: AgentCoreSandbox
+    ) -> None:
+        """Async read plane round-trips a virtual path against a non-root cwd."""
+        vpath = "/workspace/areadplane_roundtrip.txt"
+        vdir = "/workspace"
+
+        async def run() -> None:
+            write_result = await sandbox.awrite(vpath, "async needle\n")
+            assert write_result.error is None, write_result.error
+
+            read_result = await sandbox.aread(vpath)
+            assert read_result.error is None, read_result.error
+
+            ls_result = await sandbox.als(vdir)
+            assert ls_result.error is None, ls_result.error
+
+            grep_result = await sandbox.agrep("needle", vdir)
+            assert grep_result.error is None, grep_result.error
+
+            glob_result = await sandbox.aglob("*.txt", vdir)
+            assert glob_result.error is None, glob_result.error
+
+        asyncio.run(run())