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

{langchain_agentcore_codeinterpreter-0.0.4 → 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.4 → langchain_agentcore_codeinterpreter-0.0.5}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: langchain-agentcore-codeinterpreter
-Version: 0.0.4
+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.4 → 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,
 )
@@ -174,7 +177,7 @@ class AgentCoreSandbox(BaseSandbox):
         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 ``write()`` call.
+        sandbox detect it automatically on the first path operation via ``pwd``.
 
     Example:
         .. code-block:: python
@@ -209,7 +212,7 @@ class AgentCoreSandbox(BaseSandbox):
                 ``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 ``write()`` call via ``pwd``.
+                automatically on the first path operation via ``pwd``.
         """
         self._interpreter = interpreter
         self._cwd: str | None = cwd.rstrip("/") if cwd is not None else None
@@ -439,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.
@@ -448,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)
@@ -456,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:
@@ -479,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.
@@ -618,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.4 → langchain_agentcore_codeinterpreter-0.0.5}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "hatchling.build"
 
 [project]
 name = "langchain-agentcore-codeinterpreter"
-version = "0.0.4"
+version = "0.0.5"
 description = "Amazon Bedrock AgentCore Code Interpreter sandbox integration for Deep Agents"
 readme = "README.md"
 license = "MIT"
@@ -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.4 → 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())

{langchain_agentcore_codeinterpreter-0.0.4 → langchain_agentcore_codeinterpreter-0.0.5}/tests/unit_tests/test_sandbox.py

@@ -9,10 +9,19 @@ from __future__ import annotations
 import asyncio
 from collections.abc import Iterator
 from typing import Any
-from unittest.mock import MagicMock
+from unittest.mock import MagicMock, patch
 
 import pytest
 from botocore.exceptions import ClientError
+from deepagents.backends.protocol import (
+    EditResult,
+    FileData,
+    GlobResult,
+    GrepResult,
+    LsResult,
+    ReadResult,
+)
+from deepagents.backends.sandbox import BaseSandbox
 
 from langchain_agentcore_codeinterpreter import AgentCoreSandbox
 from langchain_agentcore_codeinterpreter.sandbox import (
@@ -141,12 +150,37 @@ def test_upload_files_text() -> None:
 
 
 def test_upload_files_binary_uses_blob() -> None:
-    """Non-UTF-8 content should be base64-encoded as a blob."""
+    """Non-UTF-8 content should be uploaded as raw blob bytes."""
     sandbox, mock = _make_sandbox()
-    sandbox.upload_files([("/data.bin", b"\x80\x81\x82")])
+    binary_content = b"\x80\x81\x82"
+
+    sandbox.upload_files([("/data.bin", binary_content)])
+
     content = mock.invoke.call_args.kwargs["params"]["content"][0]
     assert "blob" in content
     assert "text" not in content
+    assert content["blob"] == binary_content
+
+
+def test_upload_files_mixed_text_and_binary() -> None:
+    """Text and binary files should use the correct writeFiles fields."""
+    sandbox, mock = _make_sandbox()
+    binary_content = b"\x00\xff\xfe"
+
+    result = sandbox.upload_files(
+        [
+            ("/hello.py", b"print('hi')"),
+            ("/data.bin", binary_content),
+        ]
+    )
+
+    uploaded = mock.invoke.call_args.kwargs["params"]["content"]
+    assert uploaded == [
+        {"path": "hello.py", "text": "print('hi')"},
+        {"path": "data.bin", "blob": binary_content},
+    ]
+    assert [response.path for response in result] == ["/hello.py", "/data.bin"]
+    assert [response.error for response in result] == [None, None]
 
 
 def test_upload_files_empty_list() -> None:
@@ -570,6 +604,119 @@ def test_write_root_cwd_preserves_existing_behavior() -> None:
     assert uploaded_path == "hello.py"
 
 
+# ------------------------------------------------------------------
+# Read-plane path normalization (ls/read/grep/glob/edit)
+# ------------------------------------------------------------------
+
+
+@pytest.mark.parametrize(
+    ("method_name", "virtual_path", "expected_path", "extra_args", "return_value"),
+    [
+        (
+            "ls",
+            "/workspace",
+            "/opt/sandbox/workspace",
+            (),
+            LsResult(entries=[]),
+        ),
+        (
+            "read",
+            "/workspace/hello.py",
+            "/opt/sandbox/workspace/hello.py",
+            (0, 2000),
+            ReadResult(file_data=FileData(content="hello", encoding="utf-8")),
+        ),
+        (
+            "grep",
+            "/workspace",
+            "/opt/sandbox/workspace",
+            ("needle", None),
+            GrepResult(matches=[]),
+        ),
+        (
+            "glob",
+            "/workspace",
+            "/opt/sandbox/workspace",
+            ("*.py",),
+            GlobResult(matches=[]),
+        ),
+        (
+            "edit",
+            "/workspace/hello.py",
+            "/opt/sandbox/workspace/hello.py",
+            ("old", "new", False),
+            EditResult(path="/opt/sandbox/workspace/hello.py", occurrences=1),
+        ),
+    ],
+)
+def test_read_plane_resolves_virtual_paths(
+    method_name: str,
+    virtual_path: str,
+    expected_path: str,
+    extra_args: tuple[Any, ...],
+    return_value: Any,
+) -> None:
+    """Read-plane methods should resolve virtual paths against the sandbox cwd."""
+    sandbox, _ = _make_sandbox(cwd="/opt/sandbox")
+    result: Any
+
+    with patch.object(
+        BaseSandbox, method_name, return_value=return_value
+    ) as mock_method:
+        if method_name == "grep":
+            result = sandbox.grep(extra_args[0], virtual_path)
+            mock_method.assert_called_once_with(extra_args[0], expected_path, None)
+        elif method_name == "glob":
+            result = sandbox.glob(extra_args[0], virtual_path)
+            mock_method.assert_called_once_with(extra_args[0], expected_path)
+        elif method_name == "read":
+            result = sandbox.read(virtual_path, *extra_args)
+            mock_method.assert_called_once_with(expected_path, *extra_args)
+        elif method_name == "edit":
+            result = sandbox.edit(virtual_path, *extra_args)
+            mock_method.assert_called_once_with(expected_path, *extra_args)
+        else:
+            result = sandbox.ls(virtual_path)
+            mock_method.assert_called_once_with(expected_path)
+
+    assert result == return_value
+
+
+def test_grep_with_none_path_passes_through() -> None:
+    """grep() should not resolve when path is None (BaseSandbox defaults to '.')."""
+    sandbox, _ = _make_sandbox(cwd="/opt/sandbox")
+
+    with patch.object(
+        BaseSandbox, "grep", return_value=GrepResult(matches=[])
+    ) as mock_grep:
+        sandbox.grep("needle")
+        mock_grep.assert_called_once_with("needle", None, None)
+
+
+def test_glob_with_none_path_passes_through() -> None:
+    """glob() should not resolve when path is None (BaseSandbox defaults to '/')."""
+    sandbox, _ = _make_sandbox(cwd="/opt/sandbox")
+
+    with patch.object(
+        BaseSandbox, "glob", return_value=GlobResult(matches=[])
+    ) as mock_glob:
+        sandbox.glob("*.py")
+        mock_glob.assert_called_once_with("*.py", None)
+
+
+def test_read_root_cwd_preserves_virtual_path() -> None:
+    """When cwd is /, read() should pass virtual paths through unchanged."""
+    sandbox, _ = _make_sandbox(cwd="/")
+
+    with patch.object(
+        BaseSandbox,
+        "read",
+        return_value=ReadResult(file_data=FileData(content="ok", encoding="utf-8")),
+    ) as mock_read:
+        sandbox.read("/workspace/hello.py")
+        mock_read.assert_called_once_with("/workspace/hello.py", 0, 2000)
+
+
 # ------------------------------------------------------------------
 # _invoke() — eager stream consumption
 # ------------------------------------------------------------------
@@ -778,6 +925,37 @@ def test_aexecute_handles_session_expiry() -> None:
     assert "expired" in result.output.lower()
 
 
+def test_als_routes_through_cwd_aware_sync_ls() -> None:
+    """als() must resolve the virtual path against the cwd."""
+    sandbox, _ = _make_sandbox(cwd="/opt/sandbox")
+
+    with patch.object(BaseSandbox, "ls", return_value=LsResult(entries=[])) as mock_ls:
+        asyncio.run(sandbox.als("/workspace"))
+        mock_ls.assert_called_once_with("/opt/sandbox/workspace")
+
+
+def test_agrep_routes_through_cwd_aware_sync_grep() -> None:
+    """agrep() must resolve the virtual path against the cwd (not literal)."""
+    sandbox, _ = _make_sandbox(cwd="/opt/sandbox")
+
+    with patch.object(
+        BaseSandbox, "grep", return_value=GrepResult(matches=[])
+    ) as mock_grep:
+        asyncio.run(sandbox.agrep("needle", "/workspace"))
+        mock_grep.assert_called_once_with("needle", "/opt/sandbox/workspace", None)
+
+
+def test_aglob_routes_through_cwd_aware_sync_glob() -> None:
+    """aglob() must resolve the virtual path against the cwd (not literal)."""
+    sandbox, _ = _make_sandbox(cwd="/opt/sandbox")
+
+    with patch.object(
+        BaseSandbox, "glob", return_value=GlobResult(matches=[])
+    ) as mock_glob:
+        asyncio.run(sandbox.aglob("*.py", "/workspace"))
+        mock_glob.assert_called_once_with("*.py", "/opt/sandbox/workspace")
+
+
 # ------------------------------------------------------------------
 # Executor configuration
 # ------------------------------------------------------------------