langchain-agentcore-codeinterpreter 0.0.1__tar.gz → 0.0.2__tar.gz

{langchain_agentcore_codeinterpreter-0.0.1 → langchain_agentcore_codeinterpreter-0.0.2}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: langchain-agentcore-codeinterpreter
-Version: 0.0.1
+Version: 0.0.2
 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.1 → langchain_agentcore_codeinterpreter-0.0.2}/langchain_agentcore_codeinterpreter/sandbox.py

@@ -2,14 +2,20 @@
 
 from __future__ import annotations
 
+import asyncio
 import base64
 import logging
+from concurrent.futures import ThreadPoolExecutor
 from typing import TYPE_CHECKING, Any
 
+from botocore.exceptions import ClientError
 from deepagents.backends.protocol import (
+    EditResult,
     ExecuteResponse,
     FileDownloadResponse,
     FileUploadResponse,
+    ReadResult,
+    WriteResult,
 )
 from deepagents.backends.sandbox import BaseSandbox
 
@@ -18,6 +24,25 @@ if TYPE_CHECKING:
 
 logger = logging.getLogger(__name__)
 
+# Dedicated thread pool for AgentCore boto3 calls. Isolates sandbox I/O
+# from the default asyncio executor so long-running stream reads don't
+# starve other async work (LLM calls, tool dispatch, etc.).
+_AGENTCORE_EXECUTOR = ThreadPoolExecutor(
+    max_workers=4, thread_name_prefix="agentcore-sandbox"
+)
+
+
+class SessionExpiredError(Exception):
+    """Raised when the AgentCore session has expired or been terminated."""
+
+    def __init__(self, session_id: str, original: ClientError) -> None:
+        self.session_id = session_id
+        self.original = original
+        super().__init__(
+            f"AgentCore session '{session_id}' has expired or was terminated. "
+            f"Start a new session to continue."
+        )
+
 
 def _extract_text_from_stream(response: dict[str, Any]) -> tuple[str, int | None]:
     """Extract text output and exit code from a code interpreter response stream.
@@ -118,6 +143,10 @@ class AgentCoreSandbox(BaseSandbox):
     ``download_files()``, and ``upload_files()`` methods using AgentCore's
     streaming API.
 
+    Async methods (``aexecute``, ``awrite``, etc.) use a dedicated thread
+    pool executor to avoid blocking the default ``asyncio`` executor with
+    long-running boto3 stream reads.
+
     The caller is responsible for managing the interpreter lifecycle
     (``start()`` / ``stop()``).
 
@@ -159,11 +188,48 @@ class AgentCoreSandbox(BaseSandbox):
         """
         return path.lstrip("/")
 
+    def _invoke(self, method: str, params: dict[str, Any]) -> dict[str, Any]:
+        """Invoke the interpreter and eagerly consume the response stream.
+
+        AgentCore's ``invoke_code_interpreter`` returns a lazy EventStream
+        that holds the HTTP connection open until fully iterated. Consuming
+        it eagerly releases the connection promptly, which prevents thread
+        starvation when multiple sandbox calls are in-flight under
+        ``asyncio.to_thread`` or a thread pool executor.
+
+        Args:
+            method: The interpreter method name (e.g. ``executeCommand``).
+            params: Parameters to pass to the method.
+
+        Returns:
+            Response dict with the ``"stream"`` key materialized as a list.
+
+        Raises:
+            SessionExpiredError: If the session has expired or been terminated.
+        """
+        try:
+            response = self._interpreter.invoke(method=method, params=params)
+        except ClientError as exc:
+            error_code = exc.response.get("Error", {}).get("Code", "")
+            if error_code == "ResourceNotFoundException":
+                raise SessionExpiredError(self.id, exc) from exc
+            raise
+
+        # Eagerly consume the lazy EventStream to release the HTTP connection.
+        if "stream" in response:
+            response["stream"] = list(response["stream"])
+
+        return response
+
     @property
     def id(self) -> str:
         """Return the AgentCore session ID."""
         return self._interpreter.session_id or ""
 
+    # ------------------------------------------------------------------
+    # Sync methods
+    # ------------------------------------------------------------------
+
     def execute(
         self,
         command: str,
@@ -183,7 +249,7 @@ class AgentCoreSandbox(BaseSandbox):
             flag.
         """
         try:
-            response = self._interpreter.invoke(
+            response = self._invoke(
                 method="executeCommand", params={"command": command}
             )
             output, exit_code = _extract_text_from_stream(response)
@@ -192,6 +258,19 @@ class AgentCoreSandbox(BaseSandbox):
                 exit_code=exit_code if exit_code is not None else 0,
                 truncated=False,
             )
+        except SessionExpiredError:
+            logger.error(
+                "AgentCore session expired while executing command: %s",
+                command[:80],
+            )
+            return ExecuteResponse(
+                output=(
+                    "Error: AgentCore session has expired. "
+                    "Start a new session to continue."
+                ),
+                exit_code=1,
+                truncated=False,
+            )
         except Exception as exc:
             logger.exception("Error executing command: %s", command[:80])
             msg = f"Error executing command: {exc}"
@@ -216,7 +295,7 @@ class AgentCoreSandbox(BaseSandbox):
         """
         try:
             relative_paths = [self._to_relative_path(p) for p in paths]
-            response = self._interpreter.invoke(
+            response = self._invoke(
                 method="readFiles", params={"paths": relative_paths}
             )
             file_contents = _extract_files_from_stream(response, paths)
@@ -229,6 +308,12 @@ class AgentCoreSandbox(BaseSandbox):
                 )
                 for path in paths
             ]
+        except SessionExpiredError:
+            logger.error("AgentCore session expired while downloading files: %s", paths)
+            return [
+                FileDownloadResponse(path=path, content=None, error="permission_denied")
+                for path in paths
+            ]
         except Exception:
             logger.exception("Error downloading files: %s", paths)
             return [
@@ -261,13 +346,160 @@ class AgentCoreSandbox(BaseSandbox):
 
         try:
             if file_list:
-                self._interpreter.invoke(
-                    method="writeFiles", params={"content": file_list}
-                )
+                self._invoke(method="writeFiles", params={"content": file_list})
             return [FileUploadResponse(path=path, error=None) for path, _ in files]
+        except SessionExpiredError:
+            logger.error(
+                "AgentCore session expired while uploading files: %s",
+                [p for p, _ in files],
+            )
+            return [
+                FileUploadResponse(path=path, error="permission_denied")
+                for path, _ in files
+            ]
         except Exception:
             logger.exception("Error uploading files: %s", [p for p, _ in files])
             return [
                 FileUploadResponse(path=path, error="permission_denied")
                 for path, _ in files
             ]
+
+    # ------------------------------------------------------------------
+    # Async overrides — use a dedicated executor to avoid starving the
+    # default asyncio thread pool with long-running boto3 stream reads.
+    # ------------------------------------------------------------------
+
+    async def aexecute(
+        self,
+        command: str,
+        *,
+        timeout: int | None = None,
+    ) -> ExecuteResponse:
+        """Async version of :meth:`execute`.
+
+        Runs the sync method in a dedicated thread pool executor to avoid
+        blocking the default ``asyncio`` executor.
+
+        Args:
+            command: Shell command string to execute.
+            timeout: Unused. Accepted for interface compatibility.
+
+        Returns:
+            Response containing the command output, exit code, and truncation
+            flag.
+        """
+        loop = asyncio.get_running_loop()
+        return await loop.run_in_executor(
+            _AGENTCORE_EXECUTOR,
+            lambda: self.execute(command, timeout=timeout),
+        )
+
+    async def aread(
+        self,
+        file_path: str,
+        offset: int = 0,
+        limit: int = 2000,
+    ) -> ReadResult:
+        """Async version of :meth:`read`.
+
+        Runs the sync method in a dedicated thread pool executor.
+
+        Args:
+            file_path: Absolute path to the file to read.
+            offset: Starting line number (0-indexed).
+            limit: Maximum number of lines to return.
+
+        Returns:
+            ``ReadResult`` with ``file_data`` on success or ``error`` on
+            failure.
+        """
+        loop = asyncio.get_running_loop()
+        return await loop.run_in_executor(
+            _AGENTCORE_EXECUTOR,
+            lambda: self.read(file_path, offset, limit),
+        )
+
+    async def awrite(
+        self,
+        file_path: str,
+        content: str,
+    ) -> WriteResult:
+        """Async version of :meth:`write`.
+
+        Runs the sync method in a dedicated thread pool executor.
+
+        Args:
+            file_path: Absolute path for the new file.
+            content: UTF-8 text content to write.
+
+        Returns:
+            ``WriteResult`` with ``path`` on success or ``error`` on failure.
+        """
+        loop = asyncio.get_running_loop()
+        return await loop.run_in_executor(
+            _AGENTCORE_EXECUTOR,
+            lambda: self.write(file_path, content),
+        )
+
+    async def aedit(
+        self,
+        file_path: str,
+        old_string: str,
+        new_string: str,
+        replace_all: bool = False,  # noqa: FBT001, FBT002
+    ) -> EditResult:
+        """Async version of :meth:`edit`.
+
+        Runs the sync method in a dedicated thread pool executor.
+
+        Args:
+            file_path: Absolute path to the file to edit.
+            old_string: The exact substring to find.
+            new_string: The replacement string.
+            replace_all: If ``True``, replace every occurrence.
+
+        Returns:
+            ``EditResult`` with ``path`` and ``occurrences`` on success,
+            or ``error`` on failure.
+        """
+        loop = asyncio.get_running_loop()
+        return await loop.run_in_executor(
+            _AGENTCORE_EXECUTOR,
+            lambda: self.edit(file_path, old_string, new_string, replace_all),
+        )
+
+    async def aupload_files(
+        self, files: list[tuple[str, bytes]]
+    ) -> list[FileUploadResponse]:
+        """Async version of :meth:`upload_files`.
+
+        Runs the sync method in a dedicated thread pool executor.
+
+        Args:
+            files: List of ``(path, content)`` tuples to upload.
+
+        Returns:
+            List of :class:`FileUploadResponse` objects.
+        """
+        loop = asyncio.get_running_loop()
+        return await loop.run_in_executor(
+            _AGENTCORE_EXECUTOR,
+            lambda: self.upload_files(files),
+        )
+
+    async def adownload_files(self, paths: list[str]) -> list[FileDownloadResponse]:
+        """Async version of :meth:`download_files`.
+
+        Runs the sync method in a dedicated thread pool executor.
+
+        Args:
+            paths: List of file paths to download.
+
+        Returns:
+            List of :class:`FileDownloadResponse` objects.
+        """
+        loop = asyncio.get_running_loop()
+        return await loop.run_in_executor(
+            _AGENTCORE_EXECUTOR,
+            lambda: self.download_files(paths),
+        )

{langchain_agentcore_codeinterpreter-0.0.1 → langchain_agentcore_codeinterpreter-0.0.2}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "hatchling.build"
 
 [project]
 name = "langchain-agentcore-codeinterpreter"
-version = "0.0.1"
+version = "0.0.2"
 description = "Amazon Bedrock AgentCore Code Interpreter sandbox integration for Deep Agents"
 readme = "README.md"
 license = "MIT"

{langchain_agentcore_codeinterpreter-0.0.1 → langchain_agentcore_codeinterpreter-0.0.2}/tests/integration_tests/test_integration.py

@@ -6,8 +6,9 @@ Code Interpreter service is available.
 
 from __future__ import annotations
 
+import asyncio
 import os
-from typing import TYPE_CHECKING
+from typing import TYPE_CHECKING, Any
 
 import pytest
 
@@ -16,7 +17,6 @@ from langchain_agentcore_codeinterpreter import AgentCoreSandbox
 if TYPE_CHECKING:
     from collections.abc import Iterator
 
-
 _SKIP_REASON = "AWS credentials not configured (set AWS_REGION or AWS_DEFAULT_REGION)"
 
 
@@ -83,15 +83,55 @@ class TestAgentCoreSandboxIntegration:
 
     def test_binary_roundtrip(self, sandbox: AgentCoreSandbox) -> None:
         """Binary content uploaded via base64 may be returned as base64 text."""
+        import base64
+
         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
-        import base64
-
         assert results[0].content in (content, base64.b64encode(content))
 
     def test_session_id(self, sandbox: AgentCoreSandbox) -> None:
         """The sandbox should have a non-empty session ID."""
         assert sandbox.id != ""
+
+    # ------------------------------------------------------------------
+    # Async integration tests
+    # ------------------------------------------------------------------
+
+    def test_aexecute_echo(self, sandbox: AgentCoreSandbox) -> None:
+        """aexecute() should work against a live session."""
+        result = asyncio.run(sandbox.aexecute("echo async hello"))
+        assert result.exit_code == 0
+        assert "async hello" in result.output
+
+    def test_aexecute_python(self, sandbox: AgentCoreSandbox) -> None:
+        """aexecute() should handle Python execution."""
+        result = asyncio.run(sandbox.aexecute("python3 -c \"print('async works')\""))
+        assert result.exit_code == 0
+        assert "async works" in result.output
+
+    def test_aupload_and_adownload_roundtrip(self, sandbox: AgentCoreSandbox) -> None:
+        """Async upload and download should produce identical content."""
+        content = b"async round trip content"
+        upload_result = asyncio.run(
+            sandbox.aupload_files([("async_roundtrip.txt", content)])
+        )
+        assert upload_result[0].error is None
+
+        download_result = asyncio.run(sandbox.adownload_files(["async_roundtrip.txt"]))
+        assert download_result[0].error is None
+        assert download_result[0].content == content
+
+    def test_concurrent_aexecute(self, sandbox: AgentCoreSandbox) -> None:
+        """Multiple concurrent async executions should not deadlock."""
+
+        async def run_concurrent() -> list[Any]:
+            tasks = [sandbox.aexecute(f"echo concurrent-{i}") for i in range(3)]
+            return await asyncio.gather(*tasks)
+
+        results = asyncio.run(run_concurrent())
+        for i, result in enumerate(results):
+            assert result.exit_code == 0
+            assert f"concurrent-{i}" in result.output

{langchain_agentcore_codeinterpreter-0.0.1 → langchain_agentcore_codeinterpreter-0.0.2}/tests/unit_tests/test_imports.py

@@ -15,3 +15,10 @@ def test_import_package() -> None:
 def test_import_sandbox_class() -> None:
     """The public AgentCoreSandbox class should be importable."""
     assert AgentCoreSandbox is not None
+
+
+def test_import_session_expired_error() -> None:
+    """SessionExpiredError should be importable from the sandbox module."""
+    from langchain_agentcore_codeinterpreter.sandbox import SessionExpiredError
+
+    assert SessionExpiredError is not None