langchain-briq 0.1.0__tar.gz

langchain_briq-0.1.0/.gitignore

@@ -0,0 +1,5 @@
+.venv/
+__pycache__/
+.mypy_cache/
+.ruff_cache/
+dist/

langchain_briq-0.1.0/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 briq
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

langchain_briq-0.1.0/PKG-INFO

@@ -0,0 +1,131 @@
+Metadata-Version: 2.5
+Name: langchain-briq
+Version: 0.1.0
+Summary: briq sandbox integration for Deep Agents
+Project-URL: Homepage, https://briq.cloud
+Project-URL: Repository, https://github.com/briq-cloud/langchain-briq
+License-Expression: MIT
+License-File: LICENSE
+Keywords: agents,briq,deepagents,langchain,sandbox
+Classifier: Development Status :: 3 - Alpha
+Classifier: Intended Audience :: Developers
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Programming Language :: Python :: 3.13
+Classifier: Programming Language :: Python :: 3.14
+Classifier: Topic :: Scientific/Engineering :: Artificial Intelligence
+Classifier: Typing :: Typed
+Requires-Python: <4.0,>=3.11
+Requires-Dist: briq-cloud<0.2,>=0.1.1
+Requires-Dist: deepagents<0.8.0,>=0.7.32
+Description-Content-Type: text/markdown
+
+# langchain-briq
+
+[![PyPI](https://img.shields.io/pypi/v/langchain-briq)](https://pypi.org/project/langchain-briq/) [![CI](https://github.com/briq-cloud/langchain-briq/actions/workflows/ci.yml/badge.svg)](https://github.com/briq-cloud/langchain-briq/actions/workflows/ci.yml)
+
+[briq](https://briq.cloud) sandbox integration for [Deep Agents](https://docs.langchain.com/oss/python/deepagents/overview). A Deep Agent runs its commands and file tools in a briq sandbox.
+
+```python
+from deepagents import create_deep_agent
+from langchain_briq import BriqSandbox
+
+backend = BriqSandbox.create(size="medium")  # reads BRIQ_API_KEY
+try:
+    agent = create_deep_agent(model="anthropic:claude-sonnet-4-5", backend=backend)
+    result = agent.invoke(
+        {"messages": [{"role": "user", "content": "Write fizzbuzz in Python and run it."}]}
+    )
+    print(result["messages"][-1].content)
+finally:
+    backend.destroy()  # removes the sandbox and its disk
+```
+
+Install: `pip install langchain-briq`. Python 3.11 or later. It depends on `deepagents` and [`briq-cloud`](https://pypi.org/project/briq-cloud/). Get an API key on the briq dashboard and set `BRIQ_API_KEY`.
+
+## What it does
+
+`BriqSandbox` is a `BaseSandbox`: it implements `execute`, `upload_files`, `download_files` and `id`, and the rest of the Deep Agents filesystem tools (`read`, `write`, `edit`, `ls`, `glob`, `grep`) come from `BaseSandbox`. They run `python3` in the sandbox, which the default image has.
+
+| Method | Does |
+| --- | --- |
+| `BriqSandbox.create(...)` | Makes a sandbox and waits until it runs. |
+| `BriqSandbox.connect(id)` | Reconnects to a sandbox. A sleeping one wakes on the next call. |
+| `backend.execute(command, timeout=)` | Runs a shell command. Returns the output and the exit code. |
+| `backend.upload_files([(path, bytes)])` | Writes files, creates the directories above them. |
+| `backend.download_files([path])` | Reads files. |
+| `backend.id` | The sandbox id. |
+| `backend.destroy()` | Removes the sandbox and its disk. |
+| `backend.sandbox` | The underlying [`briq_cloud.Sandbox`](https://pypi.org/project/briq-cloud/), for previews, stop, start. |
+
+`async` methods (`aexecute`, `aupload_files`, `adownload_files`) run the same calls in a thread.
+
+### Create options
+
+```python
+BriqSandbox.create(
+    size="large",  # small, medium, large or xlarge
+    image="ghcr.io/acme/tools:1",  # an OCI image with a shell and python3
+    env={"MODE": "test"},  # shows in the sandbox's status
+    secret_env={"API_TOKEN": token},  # write-only
+    sleep="3h",  # idle time before it sleeps; "never" stays awake
+    default_timeout=600,  # seconds a command may run without its own timeout
+)
+```
+
+- Any other `size` raises `BriqError` with code `unsupported` before a request is sent.
+- `secret_env` raises `unsupported` when the API cannot keep the values write-only.
+- Pass `client=` a `briq_cloud.Briq` to share one client. You close it. Without it, `api_key` and `base_url` default to `BRIQ_API_KEY` and `BRIQ_API_URL`.
+- `with BriqSandbox.create() as backend:` destroys the sandbox when the block ends.
+
+### Reconnect
+
+```python
+backend = BriqSandbox.create(sleep="3h")
+sandbox_id = backend.id
+backend.close()  # closes the client, the sandbox keeps running
+
+backend = BriqSandbox.connect(sandbox_id)
+```
+
+## Behavior
+
+- `execute` returns stdout, then stderr inside `<stderr>` tags. A command that outlives its timeout is stopped and ends with exit code `124`. The timeout is 1 second to 24 hours; the default is 30 minutes.
+- A command over about 6 KB is written to a file in the sandbox and run from there. The API takes 8 KB of command per call.
+- `upload_files` and `download_files` return one response per path, in order. Error codes: `invalid_path` (a relative path), `file_not_found`, `permission_denied`, `is_directory`. A file over 100 MiB raises `BriqError` with code `quota`.
+- Errors the model cannot fix (a wrong key, no credits, a plan limit, a sandbox that no longer exists) raise `briq_cloud.BriqError`. Its `code` is stable; see the [client's README](https://pypi.org/project/briq-cloud/).
+
+## Not supported
+
+- Streaming output: `execute` returns when the command ends.
+- A working directory or environment per command. Put them in the command: `cd /work && make`.
+- Output truncation: `truncated` is always `False`. A command's output over 32 MiB raises `BriqError` with code `quota`.
+
+## Develop
+
+Needs [uv](https://docs.astral.sh/uv/).
+
+```sh
+git clone https://github.com/briq-cloud/langchain-briq && cd langchain-briq
+uv sync --group test
+uv run pytest                     # offline
+uv run ruff check . && uv run ruff format --check .
+uv run mypy
+```
+
+The tests run offline: `tests/unit_tests/test_sandbox.py` drives `BriqSandbox` through the real `briq-cloud` client against an in-memory API. `tests/unit_tests/test_standard_offline.py` runs the standard `SandboxIntegrationTests` suite of `langchain-tests` against a local Docker container (skipped without Docker).
+
+Seven tests of that suite expect behavior that `BaseSandbox` itself no longer has (`glob` returns absolute paths, `write` overwrites): they are marked `xfail` in `tests/conftest.py`.
+
+Against a real briq sandbox, with a key:
+
+```sh
+BRIQ_API_KEY=... uv run pytest tests/integration_tests
+```
+
+It makes one `small` sandbox for the run and destroys it.
+
+## License
+
+MIT

langchain_briq-0.1.0/README.md

@@ -0,0 +1,108 @@
+# langchain-briq
+
+[![PyPI](https://img.shields.io/pypi/v/langchain-briq)](https://pypi.org/project/langchain-briq/) [![CI](https://github.com/briq-cloud/langchain-briq/actions/workflows/ci.yml/badge.svg)](https://github.com/briq-cloud/langchain-briq/actions/workflows/ci.yml)
+
+[briq](https://briq.cloud) sandbox integration for [Deep Agents](https://docs.langchain.com/oss/python/deepagents/overview). A Deep Agent runs its commands and file tools in a briq sandbox.
+
+```python
+from deepagents import create_deep_agent
+from langchain_briq import BriqSandbox
+
+backend = BriqSandbox.create(size="medium")  # reads BRIQ_API_KEY
+try:
+    agent = create_deep_agent(model="anthropic:claude-sonnet-4-5", backend=backend)
+    result = agent.invoke(
+        {"messages": [{"role": "user", "content": "Write fizzbuzz in Python and run it."}]}
+    )
+    print(result["messages"][-1].content)
+finally:
+    backend.destroy()  # removes the sandbox and its disk
+```
+
+Install: `pip install langchain-briq`. Python 3.11 or later. It depends on `deepagents` and [`briq-cloud`](https://pypi.org/project/briq-cloud/). Get an API key on the briq dashboard and set `BRIQ_API_KEY`.
+
+## What it does
+
+`BriqSandbox` is a `BaseSandbox`: it implements `execute`, `upload_files`, `download_files` and `id`, and the rest of the Deep Agents filesystem tools (`read`, `write`, `edit`, `ls`, `glob`, `grep`) come from `BaseSandbox`. They run `python3` in the sandbox, which the default image has.
+
+| Method | Does |
+| --- | --- |
+| `BriqSandbox.create(...)` | Makes a sandbox and waits until it runs. |
+| `BriqSandbox.connect(id)` | Reconnects to a sandbox. A sleeping one wakes on the next call. |
+| `backend.execute(command, timeout=)` | Runs a shell command. Returns the output and the exit code. |
+| `backend.upload_files([(path, bytes)])` | Writes files, creates the directories above them. |
+| `backend.download_files([path])` | Reads files. |
+| `backend.id` | The sandbox id. |
+| `backend.destroy()` | Removes the sandbox and its disk. |
+| `backend.sandbox` | The underlying [`briq_cloud.Sandbox`](https://pypi.org/project/briq-cloud/), for previews, stop, start. |
+
+`async` methods (`aexecute`, `aupload_files`, `adownload_files`) run the same calls in a thread.
+
+### Create options
+
+```python
+BriqSandbox.create(
+    size="large",  # small, medium, large or xlarge
+    image="ghcr.io/acme/tools:1",  # an OCI image with a shell and python3
+    env={"MODE": "test"},  # shows in the sandbox's status
+    secret_env={"API_TOKEN": token},  # write-only
+    sleep="3h",  # idle time before it sleeps; "never" stays awake
+    default_timeout=600,  # seconds a command may run without its own timeout
+)
+```
+
+- Any other `size` raises `BriqError` with code `unsupported` before a request is sent.
+- `secret_env` raises `unsupported` when the API cannot keep the values write-only.
+- Pass `client=` a `briq_cloud.Briq` to share one client. You close it. Without it, `api_key` and `base_url` default to `BRIQ_API_KEY` and `BRIQ_API_URL`.
+- `with BriqSandbox.create() as backend:` destroys the sandbox when the block ends.
+
+### Reconnect
+
+```python
+backend = BriqSandbox.create(sleep="3h")
+sandbox_id = backend.id
+backend.close()  # closes the client, the sandbox keeps running
+
+backend = BriqSandbox.connect(sandbox_id)
+```
+
+## Behavior
+
+- `execute` returns stdout, then stderr inside `<stderr>` tags. A command that outlives its timeout is stopped and ends with exit code `124`. The timeout is 1 second to 24 hours; the default is 30 minutes.
+- A command over about 6 KB is written to a file in the sandbox and run from there. The API takes 8 KB of command per call.
+- `upload_files` and `download_files` return one response per path, in order. Error codes: `invalid_path` (a relative path), `file_not_found`, `permission_denied`, `is_directory`. A file over 100 MiB raises `BriqError` with code `quota`.
+- Errors the model cannot fix (a wrong key, no credits, a plan limit, a sandbox that no longer exists) raise `briq_cloud.BriqError`. Its `code` is stable; see the [client's README](https://pypi.org/project/briq-cloud/).
+
+## Not supported
+
+- Streaming output: `execute` returns when the command ends.
+- A working directory or environment per command. Put them in the command: `cd /work && make`.
+- Output truncation: `truncated` is always `False`. A command's output over 32 MiB raises `BriqError` with code `quota`.
+
+## Develop
+
+Needs [uv](https://docs.astral.sh/uv/).
+
+```sh
+git clone https://github.com/briq-cloud/langchain-briq && cd langchain-briq
+uv sync --group test
+uv run pytest                     # offline
+uv run ruff check . && uv run ruff format --check .
+uv run mypy
+```
+
+The tests run offline: `tests/unit_tests/test_sandbox.py` drives `BriqSandbox` through the real `briq-cloud` client against an in-memory API. `tests/unit_tests/test_standard_offline.py` runs the standard `SandboxIntegrationTests` suite of `langchain-tests` against a local Docker container (skipped without Docker).
+
+Seven tests of that suite expect behavior that `BaseSandbox` itself no longer has (`glob` returns absolute paths, `write` overwrites): they are marked `xfail` in `tests/conftest.py`.
+
+Against a real briq sandbox, with a key:
+
+```sh
+BRIQ_API_KEY=... uv run pytest tests/integration_tests
+```
+
+It makes one `small` sandbox for the run and destroys it.
+
+## License
+
+MIT

langchain_briq-0.1.0/langchain_briq/__init__.py

@@ -0,0 +1,6 @@
+"""briq sandbox integration for Deep Agents."""
+
+from langchain_briq._version import __version__
+from langchain_briq.sandbox import BriqSandbox
+
+__all__ = ["BriqSandbox", "__version__"]

langchain_briq-0.1.0/langchain_briq/_version.py

@@ -0,0 +1 @@
+__version__ = "0.1.0"

langchain_briq-0.1.0/langchain_briq/sandbox.py

@@ -0,0 +1,294 @@
+"""A Deep Agents sandbox backend that runs in a briq sandbox."""
+
+from __future__ import annotations
+
+import contextlib
+import uuid
+from collections.abc import Callable, Mapping
+from types import TracebackType
+
+from briq_cloud import Briq, BriqError, Sandbox
+from deepagents.backends.protocol import (
+    ExecuteResponse,
+    FileDownloadResponse,
+    FileUploadResponse,
+)
+from deepagents.backends.sandbox import BaseSandbox
+
+#: The sizes briq offers. Anything else is refused before a request is sent.
+SIZES = ("small", "medium", "large", "xlarge")
+
+#: Seconds a command may run when the caller sets no timeout.
+DEFAULT_TIMEOUT = 30 * 60
+
+#: The API runs a command for 1 second to 24 hours.
+_MIN_TIMEOUT = 1
+_MAX_TIMEOUT = 24 * 60 * 60
+
+#: A command longer than this many bytes is written to a file and run from there: the API takes
+#: 8,192 bytes of command per call.
+_MAX_INLINE_COMMAND = 6_000
+
+#: Exit status of a command that outlived its timeout (the one of `timeout(1)`).
+_TIMED_OUT_EXIT_CODE = 124
+
+
+class BriqSandbox(BaseSandbox):
+    """A Deep Agents backend over one briq sandbox.
+
+    Make a new sandbox, or wrap one that exists:
+
+    ```python
+    from langchain_briq import BriqSandbox
+
+    backend = BriqSandbox.create(size="medium")  # reads BRIQ_API_KEY
+    try:
+        agent = create_deep_agent(model=model, backend=backend)
+        ...
+    finally:
+        backend.destroy()
+    ```
+
+    `execute` runs a shell command, `upload_files` and `download_files` move bytes. The file tools
+    of Deep Agents (`read`, `write`, `edit`, `ls`, `glob`, `grep`) come from `BaseSandbox` and need
+    `python3` in the sandbox.
+    """
+
+    def __init__(
+        self,
+        sandbox: Sandbox,
+        *,
+        default_timeout: int = DEFAULT_TIMEOUT,
+        client: Briq | None = None,
+    ) -> None:
+        """Wrap an existing `briq_cloud.Sandbox`.
+
+        Args:
+            sandbox: The sandbox to run in.
+            default_timeout: Seconds a command may run when `execute` gets no `timeout`.
+            client: A client this backend closes with `destroy` or `close`. Leave it out when you
+                manage the client yourself.
+        """
+        self._sandbox = sandbox
+        self._default_timeout = default_timeout
+        self._owned_client = client
+
+    @classmethod
+    def create(
+        cls,
+        *,
+        api_key: str | None = None,
+        base_url: str | None = None,
+        client: Briq | None = None,
+        name: str | None = None,
+        size: str | None = None,
+        image: str | None = None,
+        env: Mapping[str, str] | None = None,
+        secret_env: Mapping[str, str] | None = None,
+        sleep: str | None = None,
+        wait_timeout: float = 120.0,
+        default_timeout: int = DEFAULT_TIMEOUT,
+    ) -> BriqSandbox:
+        """Make a sandbox and wait until it runs.
+
+        Args:
+            api_key: A briq API key. Defaults to `BRIQ_API_KEY`.
+            base_url: The API origin. Defaults to `BRIQ_API_URL`, then the public API.
+            client: A `briq_cloud.Briq` client of your own. You close it.
+            name: A name for the sandbox.
+            size: `small`, `medium`, `large` or `xlarge`.
+            image: An OCI image with a shell and `python3`.
+            env: Variables of the sandbox. They show in its status.
+            secret_env: Variables kept write-only. A `BriqError` with code `unsupported` when
+                the API cannot keep them so.
+            sleep: Idle time before it sleeps: `"30m"`, `"3h"`, `"7d"` or `"never"`.
+            wait_timeout: Seconds to wait until it runs.
+            default_timeout: Seconds a command may run when `execute` gets no `timeout`.
+
+        Raises:
+            BriqError: With code `unsupported` for another `size`, and for the API's own refusals.
+        """
+        if size is not None and size not in SIZES:
+            msg = f"Unsupported size {size!r}: use one of {', '.join(SIZES)}"
+            raise BriqError("unsupported", msg)
+        owned = client is None
+        briq = client or Briq(api_key, base_url=base_url)
+        try:
+            sandbox = briq.create_sandbox(
+                name=name,
+                size=size,
+                image=image,
+                env=env,
+                secret_env=secret_env,
+                sleep=sleep,
+                wait_timeout=wait_timeout,
+            )
+        except BaseException:
+            if owned:
+                briq.close()
+            raise
+        return cls(sandbox, default_timeout=default_timeout, client=briq if owned else None)
+
+    @classmethod
+    def connect(
+        cls,
+        sandbox_id: str,
+        *,
+        api_key: str | None = None,
+        base_url: str | None = None,
+        client: Briq | None = None,
+        default_timeout: int = DEFAULT_TIMEOUT,
+    ) -> BriqSandbox:
+        """Reconnect to a sandbox by id. A sleeping sandbox wakes on the next call."""
+        owned = client is None
+        briq = client or Briq(api_key, base_url=base_url)
+        try:
+            sandbox = briq.sandbox(sandbox_id)
+        except BaseException:
+            if owned:
+                briq.close()
+            raise
+        return cls(sandbox, default_timeout=default_timeout, client=briq if owned else None)
+
+    @property
+    def id(self) -> str:
+        """The sandbox's id: pass it to `connect` to reach the sandbox again."""
+        return self._sandbox.id
+
+    @property
+    def sandbox(self) -> Sandbox:
+        """The `briq_cloud.Sandbox` underneath, for what this backend does not wrap."""
+        return self._sandbox
+
+    def execute(self, command: str, *, timeout: int | None = None) -> ExecuteResponse:
+        """Run a shell command and return its output and exit code.
+
+        stderr follows stdout, inside `<stderr>` tags. A command that outlives `timeout` is
+        stopped and ends with exit code 124.
+        """
+        if not command.strip():
+            return ExecuteResponse(output="", exit_code=0, truncated=False)
+        seconds = self._default_timeout if timeout is None else timeout
+        seconds = min(max(seconds, _MIN_TIMEOUT), _MAX_TIMEOUT)
+        if len(command.encode("utf-8", "replace")) > _MAX_INLINE_COMMAND:
+            return self._execute_script(command, seconds)
+        return self._run(command, seconds)
+
+    def upload_files(self, files: list[tuple[str, bytes]]) -> list[FileUploadResponse]:
+        """Write files, creating the directories above them. One response per file, in order."""
+        responses: list[FileUploadResponse] = []
+        for path, content in files:
+            if not _is_absolute(path):
+                responses.append(FileUploadResponse(path=path, error="invalid_path"))
+                continue
+            try:
+                self._sandbox.write_file(path, content)
+            except BriqError as error:
+                normalized = _file_error(error)
+                if normalized is None:
+                    raise
+                responses.append(FileUploadResponse(path=path, error=normalized))
+            else:
+                responses.append(FileUploadResponse(path=path))
+        return responses
+
+    def download_files(self, paths: list[str]) -> list[FileDownloadResponse]:
+        """Read files. One response per path, in order; a missing file is an error code."""
+        responses: list[FileDownloadResponse] = []
+        for path in paths:
+            if not _is_absolute(path):
+                responses.append(FileDownloadResponse(path=path, error="invalid_path"))
+                continue
+            try:
+                content = self._sandbox.read_file(path)
+            except BriqError as error:
+                normalized = _file_error(error)
+                if normalized is None:
+                    raise
+                responses.append(FileDownloadResponse(path=path, error=normalized))
+            else:
+                responses.append(FileDownloadResponse(path=path, content=content))
+        return responses
+
+    def destroy(self) -> None:
+        """Destroy the sandbox and its disk, then close the client this backend made."""
+        try:
+            self._sandbox.destroy()
+        finally:
+            self.close()
+
+    def close(self) -> None:
+        """Close the client this backend made. The sandbox keeps running."""
+        if self._owned_client is not None:
+            self._owned_client.close()
+            self._owned_client = None
+
+    def __enter__(self) -> BriqSandbox:
+        return self
+
+    def __exit__(
+        self,
+        exc_type: type[BaseException] | None,
+        exc: BaseException | None,
+        tb: TracebackType | None,
+    ) -> None:
+        """Destroy the sandbox when the block ends."""
+        try:
+            self.destroy()
+        except BriqError:
+            if exc is None:
+                raise
+
+    def _run(self, command: str, seconds: float) -> ExecuteResponse:
+        result = self._sandbox.exec(command, timeout=seconds)
+        output = result.stdout
+        if result.stderr:
+            output = _append(output, f"<stderr>{result.stderr.rstrip(chr(10))}</stderr>")
+        if result.timed_out or result.exit_code is None:
+            note = f"Command timed out after {seconds:g} seconds"
+            output = _append(output, note)
+            return ExecuteResponse(output=output, exit_code=_TIMED_OUT_EXIT_CODE, truncated=False)
+        return ExecuteResponse(output=output, exit_code=result.exit_code, truncated=False)
+
+    def _execute_script(self, command: str, seconds: float) -> ExecuteResponse:
+        """Run a command too long for one call from a script file, then delete the file."""
+        path = f"/tmp/.langchain-briq-{uuid.uuid4().hex}.sh"
+        self._sandbox.write_file(path, command.encode("utf-8"))
+        try:
+            return self._run(f"/bin/sh {path}", seconds)
+        finally:
+            _quietly(self._sandbox.remove, path)
+
+
+def _append(output: str, line: str) -> str:
+    """`line` on a line of its own after `output`."""
+    if not output or output.endswith("\n"):
+        return output + line
+    return f"{output}\n{line}"
+
+
+def _is_absolute(path: str) -> bool:
+    return path.startswith("/") and "\0" not in path
+
+
+def _quietly(call: Callable[..., object], *args: object) -> None:
+    with contextlib.suppress(BriqError):
+        call(*args)
+
+
+def _file_error(error: BriqError) -> str | None:
+    """The `FileOperationError` for a failed file call, or `None` when it is not the file's fault.
+
+    `None` covers what the model cannot fix (credentials, limits, a sandbox that is gone): the
+    caller raises it.
+    """
+    said = error.message.lower()
+    if "permission denied" in said:
+        return "permission_denied"
+    if "is a directory" in said:
+        return "is_directory"
+    if error.code == "file_not_found":
+        return "file_not_found"
+    if error.code == "invalid_argument":
+        return "invalid_path"
+    return None

langchain_briq-0.1.0/pyproject.toml

@@ -0,0 +1,77 @@
+[build-system]
+requires = ["hatchling>=1.25"]
+build-backend = "hatchling.build"
+
+[project]
+name = "langchain-briq"
+dynamic = ["version"]
+description = "briq sandbox integration for Deep Agents"
+readme = "README.md"
+requires-python = ">=3.11,<4.0"
+license = "MIT"
+license-files = ["LICENSE"]
+keywords = ["briq", "langchain", "deepagents", "sandbox", "agents"]
+classifiers = [
+  "Development Status :: 3 - Alpha",
+  "Intended Audience :: Developers",
+  "Programming Language :: Python :: 3",
+  "Programming Language :: Python :: 3.11",
+  "Programming Language :: Python :: 3.12",
+  "Programming Language :: Python :: 3.13",
+  "Programming Language :: Python :: 3.14",
+  "Topic :: Scientific/Engineering :: Artificial Intelligence",
+  "Typing :: Typed",
+]
+dependencies = [
+  "deepagents>=0.7.32,<0.8.0",
+  "briq-cloud>=0.1.1,<0.2",
+]
+
+[project.urls]
+Homepage = "https://briq.cloud"
+Repository = "https://github.com/briq-cloud/langchain-briq"
+
+[dependency-groups]
+test = [
+  "pytest>=8",
+  "pytest-asyncio>=1.0",
+  "langchain-tests>=1.1.9",
+  "ruff>=0.6",
+  "mypy>=1.11",
+]
+
+[tool.hatch.version]
+path = "langchain_briq/_version.py"
+
+[tool.hatch.build.targets.wheel]
+packages = ["langchain_briq"]
+
+[tool.hatch.build.targets.sdist]
+include = ["langchain_briq", "README.md", "LICENSE", "pyproject.toml"]
+
+[tool.pytest.ini_options]
+testpaths = ["tests"]
+addopts = "-p no:cacheprovider --strict-markers"
+asyncio_mode = "auto"
+asyncio_default_fixture_loop_scope = "function"
+filterwarnings = [
+  "ignore:Class-scoped fixtures defined as instance methods",
+]
+markers = [
+  "requires: mark tests as requiring a specific library",
+  "compile: placeholder test used to compile integration tests without running them",
+  "scheduled: tests run on a schedule",
+]
+
+[tool.ruff]
+line-length = 100
+target-version = "py311"
+
+[tool.ruff.lint]
+select = ["E", "F", "W", "I", "UP", "B", "SIM", "RUF", "C4", "PT"]
+ignore = ["PT018", "PT012"]
+
+[tool.mypy]
+strict = true
+python_version = "3.11"
+files = ["langchain_briq", "tests"]