chalkcompute 2.13.2__tar.gz → 2.13.4__tar.gz

{chalkcompute-2.13.2 → chalkcompute-2.13.4}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: chalkcompute
-Version: 2.13.2
+Version: 2.13.4
 Requires-Dist: chalk-remote-call-python>=1.10.4
 Requires-Dist: pyyaml>=6.0.0
 Requires-Dist: opentelemetry-api>=1.20.0
@@ -34,27 +34,33 @@ or local `chalk-remote-call-python` changes, see
 ## Install
 
 ```
-pip install grpcio protobuf
+pip install chalkcompute
 ```
 
 ## Quick start
 
 ```python
-from chalkcompute import SandboxClient
-
-with SandboxClient.from_env() as client:
-    # Create a sandbox from a pre-built image
-    sandbox = client.create(image="ubuntu:latest")
+import chalkcompute as cc
 
-    # Run a command
+# Omitting image= uses Image.sandbox(): Python, Git and SSH in /workspace.
+# Credentials come from the environment, as with SandboxClient.from_env().
+sandbox = cc.Sandbox(
+    image=cc.Image.sandbox().with_tmux(),
+    cpu="1",
+    memory="2Gi",
+).run()
+try:
     result = sandbox.exec("echo", "hello world")
-    print(result.stdout_text)  # "hello world"
+    print(result.stdout_text)  # "hello world\n"
     print(result.exit_code)    # 0
-
-    # Clean up
+finally:
     sandbox.terminate()
 ```
 
+`Sandbox(...)` only describes the sandbox; `.run()` builds the image, starts it
+and waits until it is ready. See [Coding agent tools](#coding-agent-tools) for a
+sandbox with Claude Code, `gh` and Git identity configured.
+
 ## Logging and progress
 
 The SDK leaves Python logging configuration to your application. Importing
@@ -279,6 +285,78 @@ img = (
 )
 ```
 
+### Coding agent tools
+
+`with_claude_code`, `with_gh` and `with_tmux` install common agent tooling on
+Debian or Ubuntu images. `with_claude_code` installs the native binary from
+Anthropic's apt repository, pins the version (apt installs don't auto-update),
+and pre-accepts Claude Code's onboarding and trust prompts for the directories
+you list, so interactive `claude` starts without a login screen:
+
+```python
+image = (
+    Image.sandbox()
+    .with_claude_code(
+        version="2.1.270",
+        trusted_dirs=["/workspace/app"],  # the repo root, not a parent of it
+        permission_mode="bypassPermissions",  # optional
+    )
+    .with_gh()  # from GitHub's apt repo; authenticates from GH_TOKEN
+    .with_tmux()
+    .workdir("/workspace/app")
+)
+```
+
+The bypass-permissions warning is skipped by default
+(`skip_dangerous_mode_prompt=True`). Bypass mode works as root because Chalk
+sets `IS_SANDBOX=1` in every sandbox. If you supply `ANTHROPIC_API_KEY` instead
+of `CLAUDE_CODE_OAUTH_TOKEN`, pass `api_key_env="ANTHROPIC_API_KEY"` to skip the
+key-approval prompt. Anything else goes in `settings`, which is merged into
+`~/.claude/settings.json`. The theme defaults to `"dark"` (`theme=`), and
+`CLAUDE_CODE_DISABLE_NONESSENTIAL_TRAFFIC=1` is set in the image so telemetry
+and update checks don't hit hosts a network policy blocks
+(`disable_nonessential_traffic=False` to keep them). See the `with_claude_code`
+docstring for how directory trust works.
+
+To keep the token itself out of the sandbox, use `add_credentials` (see
+[Environment and secrets](#environment-variables-and-secrets)):
+`sandbox.add_credentials("api.anthropic.com",
+Secret.from_chalk_env("CLAUDE_TOKEN", alias="CLAUDE_CODE_OAUTH_TOKEN"))`.
+
+Set Git identity per sandbox, not per image, with `GitConfig`. It is a mapping
+of `GIT_*` environment variables, so it can be unpacked into `env`:
+
+```python
+sandbox = Sandbox(
+    image=image,
+    env={
+        **GitConfig(
+            name="Ada Lovelace",
+            email="ada@example.com",
+            config={"pull.rebase": "true"},
+        ),
+        "LOG_LEVEL": "debug",
+    },
+).run()
+```
+
+To push and pull over SSH, add `SshDest.github` to `managed_ssh`. It is pinned
+to GitHub's published host keys and reads the private key from a Chalk secret,
+so `git@github.com:org/repo.git` URLs work unchanged:
+
+```python
+sandbox = Sandbox(
+    image=image,
+    compute_class=ComputeClass.HOST,
+    managed_ssh=[SshDest.github("GITHUB_DEPLOY_KEY")],
+).run()
+sandbox.git.clone("git@github.com:org/repo.git", "/workspace/repo")
+```
+
+Pass `port_443=True` for networks that block port 22. To use more than one key,
+give each a distinct `alias` and use it in remote URLs, as in
+`git@github-work:org/repo.git`.
+
 ### Immutable composition
 
 Each builder method returns a new `Image`, so intermediate images can be shared:

{chalkcompute-2.13.2 → chalkcompute-2.13.4}/README.md

@@ -9,27 +9,33 @@ or local `chalk-remote-call-python` changes, see
 ## Install
 
 ```
-pip install grpcio protobuf
+pip install chalkcompute
 ```
 
 ## Quick start
 
 ```python
-from chalkcompute import SandboxClient
-
-with SandboxClient.from_env() as client:
-    # Create a sandbox from a pre-built image
-    sandbox = client.create(image="ubuntu:latest")
+import chalkcompute as cc
 
-    # Run a command
+# Omitting image= uses Image.sandbox(): Python, Git and SSH in /workspace.
+# Credentials come from the environment, as with SandboxClient.from_env().
+sandbox = cc.Sandbox(
+    image=cc.Image.sandbox().with_tmux(),
+    cpu="1",
+    memory="2Gi",
+).run()
+try:
     result = sandbox.exec("echo", "hello world")
-    print(result.stdout_text)  # "hello world"
+    print(result.stdout_text)  # "hello world\n"
     print(result.exit_code)    # 0
-
-    # Clean up
+finally:
     sandbox.terminate()
 ```
 
+`Sandbox(...)` only describes the sandbox; `.run()` builds the image, starts it
+and waits until it is ready. See [Coding agent tools](#coding-agent-tools) for a
+sandbox with Claude Code, `gh` and Git identity configured.
+
 ## Logging and progress
 
 The SDK leaves Python logging configuration to your application. Importing
@@ -254,6 +260,78 @@ img = (
 )
 ```
 
+### Coding agent tools
+
+`with_claude_code`, `with_gh` and `with_tmux` install common agent tooling on
+Debian or Ubuntu images. `with_claude_code` installs the native binary from
+Anthropic's apt repository, pins the version (apt installs don't auto-update),
+and pre-accepts Claude Code's onboarding and trust prompts for the directories
+you list, so interactive `claude` starts without a login screen:
+
+```python
+image = (
+    Image.sandbox()
+    .with_claude_code(
+        version="2.1.270",
+        trusted_dirs=["/workspace/app"],  # the repo root, not a parent of it
+        permission_mode="bypassPermissions",  # optional
+    )
+    .with_gh()  # from GitHub's apt repo; authenticates from GH_TOKEN
+    .with_tmux()
+    .workdir("/workspace/app")
+)
+```
+
+The bypass-permissions warning is skipped by default
+(`skip_dangerous_mode_prompt=True`). Bypass mode works as root because Chalk
+sets `IS_SANDBOX=1` in every sandbox. If you supply `ANTHROPIC_API_KEY` instead
+of `CLAUDE_CODE_OAUTH_TOKEN`, pass `api_key_env="ANTHROPIC_API_KEY"` to skip the
+key-approval prompt. Anything else goes in `settings`, which is merged into
+`~/.claude/settings.json`. The theme defaults to `"dark"` (`theme=`), and
+`CLAUDE_CODE_DISABLE_NONESSENTIAL_TRAFFIC=1` is set in the image so telemetry
+and update checks don't hit hosts a network policy blocks
+(`disable_nonessential_traffic=False` to keep them). See the `with_claude_code`
+docstring for how directory trust works.
+
+To keep the token itself out of the sandbox, use `add_credentials` (see
+[Environment and secrets](#environment-variables-and-secrets)):
+`sandbox.add_credentials("api.anthropic.com",
+Secret.from_chalk_env("CLAUDE_TOKEN", alias="CLAUDE_CODE_OAUTH_TOKEN"))`.
+
+Set Git identity per sandbox, not per image, with `GitConfig`. It is a mapping
+of `GIT_*` environment variables, so it can be unpacked into `env`:
+
+```python
+sandbox = Sandbox(
+    image=image,
+    env={
+        **GitConfig(
+            name="Ada Lovelace",
+            email="ada@example.com",
+            config={"pull.rebase": "true"},
+        ),
+        "LOG_LEVEL": "debug",
+    },
+).run()
+```
+
+To push and pull over SSH, add `SshDest.github` to `managed_ssh`. It is pinned
+to GitHub's published host keys and reads the private key from a Chalk secret,
+so `git@github.com:org/repo.git` URLs work unchanged:
+
+```python
+sandbox = Sandbox(
+    image=image,
+    compute_class=ComputeClass.HOST,
+    managed_ssh=[SshDest.github("GITHUB_DEPLOY_KEY")],
+).run()
+sandbox.git.clone("git@github.com:org/repo.git", "/workspace/repo")
+```
+
+Pass `port_443=True` for networks that block port 22. To use more than one key,
+give each a distinct `alias` and use it in remote URLs, as in
+`git@github-work:org/repo.git`.
+
 ### Immutable composition
 
 Each builder method returns a new `Image`, so intermediate images can be shared:

{chalkcompute-2.13.2 → chalkcompute-2.13.4}/chalkcompute/__init__.py

@@ -45,6 +45,7 @@ _LAZY_MAP: dict[str, tuple[str, str]] = {
     "FunctionCallHandle": ("chalkcompute._function", "FunctionCallHandle"),
     "FunctionVersionInfo": ("chalkcompute._function", "FunctionVersionInfo"),
     "gather": ("chalkcompute._function", "gather"),
+    "gather_handles": ("chalkcompute._gather", "gather_handles"),
     # _sql.py
     "SQLClient": ("chalkcompute._sql", "SQLClient"),
     "SQLResult": ("chalkcompute._sql", "SQLResult"),
@@ -140,6 +141,7 @@ _LAZY_MAP: dict[str, tuple[str, str]] = {
     "GitFileStatus": ("chalkcompute._sandbox_git", "GitFileStatus"),
     "GitStatus": ("chalkcompute._sandbox_git", "GitStatus"),
     "GitRemote": ("chalkcompute._sandbox_git", "GitRemote"),
+    "GitConfig": ("chalkcompute._git", "GitConfig"),
     "GitError": ("chalkcompute._git", "GitError"),
     # _sandbox.py
     "ExecError": ("chalkcompute._sandbox", "ExecError"),

{chalkcompute-2.13.2 → chalkcompute-2.13.4}/chalkcompute/__init__.pyi

@@ -68,6 +68,7 @@ from chalkcompute._function import FunctionVersionInfo as FunctionVersionInfo
 from chalkcompute._function import RemoteFunction as RemoteFunction
 from chalkcompute._function import function as function
 from chalkcompute._function import gather as gather
+from chalkcompute._gather import gather_handles as gather_handles
 from chalkcompute._function_error import RemoteExecutionError as RemoteExecutionError
 from chalkcompute._http import HTTPHeaders as HTTPHeaders
 from chalkcompute._http import HTTPResponse as HTTPResponse
@@ -161,6 +162,7 @@ from chalkcompute._sandbox_git import SandboxGit as SandboxGit
 from chalkcompute._sandbox_git import GitFileStatus as GitFileStatus
 from chalkcompute._sandbox_git import GitStatus as GitStatus
 from chalkcompute._sandbox_git import GitRemote as GitRemote
+from chalkcompute._git import GitConfig as GitConfig
 from chalkcompute._git import GitError as GitError
 
 __all__ = [
@@ -169,6 +171,7 @@ __all__ = [
     "GitFileStatus",
     "GitStatus",
     "GitRemote",
+    "GitConfig",
     "GitError",
     "SQLClient",
     "SQLResult",
@@ -208,6 +211,7 @@ __all__ = [
     "FunctionCallHandle",
     "FunctionVersionInfo",
     "gather",
+    "gather_handles",
     "get_call_context",
     "get_row_metadata",
     "RetryPolicy",

chalkcompute-2.13.4/chalkcompute/_async_utils.py

@@ -0,0 +1,41 @@
+from __future__ import annotations
+
+import asyncio
+import contextvars
+import threading
+from typing import Any, Callable
+
+
+def _has_running_event_loop() -> bool:
+    try:
+        asyncio.get_running_loop()
+    except RuntimeError:
+        return False
+    return True
+
+
+async def _run_in_worker_thread(
+    func: Callable[..., Any], *args: Any, **kwargs: Any
+) -> Any:
+    loop = asyncio.get_running_loop()
+    future: asyncio.Future[Any] = loop.create_future()
+    context = contextvars.copy_context()
+
+    def complete_with_result(value: Any) -> None:
+        if not future.cancelled():
+            future.set_result(value)
+
+    def complete_with_exception(exc: BaseException) -> None:
+        if not future.cancelled():
+            future.set_exception(exc)
+
+    def run() -> None:
+        try:
+            value = context.run(func, *args, **kwargs)
+        except BaseException as exc:
+            loop.call_soon_threadsafe(complete_with_exception, exc)
+        else:
+            loop.call_soon_threadsafe(complete_with_result, value)
+
+    threading.Thread(target=run, daemon=True).start()
+    return await future

{chalkcompute-2.13.2 → chalkcompute-2.13.4}/chalkcompute/_client_cache.py

@@ -4,7 +4,7 @@ from __future__ import annotations
 
 import logging
 import threading
-from collections.abc import Callable, Iterator
+from collections.abc import Callable, Generator
 from contextlib import contextmanager
 from dataclasses import dataclass
 from typing import Generic, TypeVar
@@ -59,7 +59,7 @@ class ClientCache(Generic[ClientT]):
         return self._acquire(key, borrow=False).client
 
     @contextmanager
-    def borrow(self, *, key: object = None) -> Iterator[ClientT]:
+    def borrow(self, *, key: object = None) -> Generator[ClientT, None, None]:
         entry = self._acquire(key, borrow=True)
         try:
             yield entry.client

{chalkcompute-2.13.2 → chalkcompute-2.13.4}/chalkcompute/_containerspec.py

@@ -73,6 +73,10 @@ class SSHDest:
         SSH destination port. Defaults to 22.
     username
         Optional SSH username written to the generated alias's ``User`` setting.
+    alias
+        Name the destination is reachable by inside the sandbox, as in
+        ``ssh <alias>``. Used when ``managed_ssh`` is a list; defaults to
+        ``host``. A ``managed_ssh`` mapping's keys take precedence.
     """
 
     host: str
@@ -81,6 +85,53 @@ class SSHDest:
     host_keys: Sequence[str] | None = None
     port: int | None = None
     username: str | None = None
+    alias: str | None = None
+
+    @classmethod
+    def github(
+        cls,
+        private_key_secret: str,
+        *,
+        alias: str = "github.com",
+        port_443: bool = False,
+    ) -> SSHDest:
+        """GitHub over SSH, pinned to GitHub's published host keys.
+
+        ``git@github.com:org/repo.git`` URLs work unchanged inside the sandbox.
+
+        Parameters
+        ----------
+        private_key_secret
+            Name of the Chalk secret containing a key registered with GitHub,
+            such as a deploy key or a user's SSH key.
+        alias
+            SSH alias for the destination. Use distinct aliases to reach
+            GitHub with more than one key, as in
+            ``git@github-work:org/repo.git``.
+        port_443
+            Connect to ``ssh.github.com:443`` instead of ``github.com:22``,
+            for networks that block port 22.
+
+        Example
+        -------
+        ```python
+        import chalkcompute as cc
+
+        sandbox = cc.Sandbox(
+            compute_class=cc.ComputeClass.HOST,
+            managed_ssh=[cc.SshDest.github("GITHUB_DEPLOY_KEY")],
+        ).run()
+        sandbox.git.clone(url="git@github.com:org/repo.git", path="/workspace/repo")
+        ```
+        """
+        return cls(
+            host="ssh.github.com" if port_443 else "github.com",
+            private_key_secret=private_key_secret,
+            host_keys=GITHUB_SSH_HOST_KEYS,
+            port=443 if port_443 else None,
+            username="git",
+            alias=alias,
+        )
 
     def __post_init__(self) -> None:
         for name, value in (
@@ -101,6 +152,8 @@ class SSHDest:
             _validate_port(self.port, "port")
         if self.username is not None and not isinstance(self.username, str):
             raise TypeError("username must be a string")
+        if self.alias is not None:
+            _validate_ssh_alias(self.alias)
 
     def to_dict(self) -> dict[str, Any]:
         destination: dict[str, Any] = {
@@ -120,6 +173,57 @@ class SSHDest:
 SshDest = SSHDest
 
 
+# GitHub's SSH host keys, from https://api.github.com/meta. ssh.github.com:443
+# serves the same keys.
+GITHUB_SSH_HOST_KEYS = (
+    "ssh-ed25519 AAAAC3NzaC1lZDI1NTE5AAAAIOMqqnkVzrm0SdG6UOoqKLsabgH5C9okWi0dh2l9GKJl",
+    "ecdsa-sha2-nistp256 AAAAE2VjZHNhLXNoYTItbmlzdHAyNTYAAAAIbmlzdHAyNTYAAABBBEmKSENjQEezOmxkZMy7opKgwFB9nkt5YRrYMjNuG5N87uRgg6CLrbo5wAdT/y6v0mKV0U2w0WZ2YB/++Tpockg=",
+    "ssh-rsa AAAAB3NzaC1yc2EAAAADAQABAAABgQCj7ndNxQowgcQnjshcLrqPEiiphnt+VTTvDP6mHBL9j1aNUkY4Ue1gvwnGLVlOhGeYrnZaMgRK6+PKCUXaDbC7qtbW8gIkhL7aGCsOr/C56SJMy/BCZfxd1nWzAOxSDPgVsmerOBYfNqltV9/hWCqBywINIR+5dIg6JTJ72pcEpEjcYgXkE2YEFXV1JHnsKgbLWNlhScqb2UmyRkQyytRLtL+38TGxkxCflmO+5Z8CSSNY7GidjMIZ7Q4zMjA2n1nGrlTDkzwDCsw+wqFPGQA179cnfGWOWRVruj16z6XyvxvjJwbz0wQZ75XK5tKSb7FNyeIEs4TT4jk+S4dhPeAUC5y+bDYirYgM4GC7uEnztnZyaVWQ7B381AK4Qdrwt51ZqExKbQpTUNn+EjqoTwvqNj4kqx5QUCI0ThS/YkOxJCXmPUWZbhjpCg56i+2aB6CmK2JGhn57K5mj0MNdBXA4/WnwH6XoPWJzK5Nyu2zB3nAZp+S5hpQs+p1vN1/wsjk=",
+)
+
+
+def _validate_ssh_alias(alias: object) -> None:
+    if not isinstance(alias, str):
+        raise TypeError("managed_ssh aliases must be strings")
+    if not alias:
+        raise ValueError("managed_ssh aliases must not be empty")
+
+
+def normalize_managed_ssh(
+    managed_ssh: Mapping[str, SSHDest] | Sequence[SSHDest] | None,
+) -> dict[str, SSHDest]:
+    """Validate ``managed_ssh`` and return it keyed by alias.
+
+    A list keys each destination by its ``alias``, falling back to ``host``.
+    """
+    if managed_ssh is None:
+        return {}
+    if isinstance(managed_ssh, Mapping):
+        items = list(managed_ssh.items())
+    elif isinstance(managed_ssh, (str, bytes)) or not isinstance(managed_ssh, Sequence):
+        raise TypeError(
+            "managed_ssh must be a list of SSHDest or a mapping of aliases to SSHDest"
+        )
+    else:
+        items = []
+        for destination in managed_ssh:
+            if not isinstance(destination, SSHDest):
+                raise TypeError("managed_ssh destinations must be SSHDest instances")
+            items.append((destination.alias or destination.host, destination))
+    result: dict[str, SSHDest] = {}
+    for alias, destination in items:
+        _validate_ssh_alias(alias)
+        if not isinstance(destination, SSHDest):
+            raise TypeError("managed_ssh destinations must be SSHDest instances")
+        if alias in result:
+            raise ValueError(
+                f"managed_ssh has more than one destination for alias {alias!r}; "
+                "give each a distinct alias="
+            )
+        result[alias] = destination
+    return result
+
+
 @dataclass
 class ContainerSecurityPolicy:
     """Security policy settings for a container."""
@@ -406,7 +510,7 @@ class ContainerSpec:
     secret_refs: Sequence[Secret | Mapping[str, Any]] = ()
     port: int | None = None
     lifetime: str | None = None
-    managed_ssh: Mapping[str, SSHDest] = field(default_factory=dict)
+    managed_ssh: Mapping[str, SSHDest] | Sequence[SSHDest] = field(default_factory=dict)
     tags: Mapping[str, str] = field(default_factory=dict)
     protocol: str | None = None
     authentication: str | None = None
@@ -461,7 +565,7 @@ class ContainerSpec:
         object.__setattr__(
             self,
             "managed_ssh",
-            dict(self.managed_ssh),
+            normalize_managed_ssh(self.managed_ssh),
         )
         object.__setattr__(
             self,
@@ -494,7 +598,7 @@ class ContainerSpec:
         tags: Mapping[str, str] | None = None,
         restart_policy: RestartPolicy | None = None,
         chalk_identity: bool = False,
-        managed_ssh: Mapping[str, SSHDest] | None = None,
+        managed_ssh: Mapping[str, SSHDest] | Sequence[SSHDest] | None = None,
     ) -> None:
         if image is not None and not isinstance(image, str):
             if not isinstance(image, Image):
@@ -569,18 +673,7 @@ class ContainerSpec:
             raise TypeError("restart_policy must be a RestartPolicy")
         if not isinstance(chalk_identity, bool):
             raise TypeError("chalk_identity must be a bool")
-        if managed_ssh is not None and not isinstance(managed_ssh, Mapping):
-            raise TypeError("managed_ssh must be a mapping of aliases to destinations")
-        if managed_ssh is not None:
-            for alias, destination in managed_ssh.items():
-                if not isinstance(alias, str):
-                    raise TypeError("managed_ssh aliases must be strings")
-                if not alias:
-                    raise ValueError("managed_ssh aliases must not be empty")
-                if not isinstance(destination, SSHDest):
-                    raise TypeError(
-                        "managed_ssh destinations must be SSHDest instances"
-                    )
+        normalize_managed_ssh(managed_ssh)
 
     def to_dict(self) -> dict[str, Any]:
         spec: dict[str, Any] = {"image": self.image}
@@ -615,7 +708,9 @@ class ContainerSpec:
         if self.managed_ssh:
             spec["managedSsh"] = {
                 alias: destination.to_dict()
-                for alias, destination in self.managed_ssh.items()
+                for alias, destination in normalize_managed_ssh(
+                    self.managed_ssh
+                ).items()
             }
         if self.tags:
             spec["tags"] = dict(self.tags)
@@ -697,7 +792,9 @@ class ContainerSpec:
                     port=destination.port,
                     username=destination.username,
                 )
-                for alias, destination in self.managed_ssh.items()
+                for alias, destination in normalize_managed_ssh(
+                    self.managed_ssh
+                ).items()
             },
             tags=dict(self.tags),
             protocol=self.protocol,

{chalkcompute-2.13.2 → chalkcompute-2.13.4}/chalkcompute/_function.py

@@ -68,7 +68,9 @@ from protobuf import Oneof
 from protobuf.wkt import FieldMask
 
 from chalkcompute import _local_dev
+from chalkcompute._async_utils import _has_running_event_loop, _run_in_worker_thread
 from chalkcompute._client_cache import ClientCache
+from chalkcompute._gather import gather_handles
 from chalkcompute._logging import _StatusLogger
 from chalkcompute._traceback import format_exception, format_frame
 from chalkcompute._terminal import styled, supports_color
@@ -232,7 +234,7 @@ def _await_deploy_predecessor(predecessor: Future[None] | None) -> None:
 
 
 @contextlib.contextmanager
-def _manual_deploy_slot(registered_name: str) -> typing.Iterator[None]:
+def _manual_deploy_slot(registered_name: str) -> typing.Generator[None, None, None]:
     """Hold a caller-initiated deploy's place in its registered name's chain.
 
     Without a slot a manual ``deploy()`` is invisible to the chain, so a
@@ -897,14 +899,6 @@ def _should_call_via_api() -> bool:
     return os.environ.get(_CALL_VIA_API_ENV_VAR, "") == "1"
 
 
-def _has_running_event_loop() -> bool:
-    try:
-        asyncio.get_running_loop()
-    except RuntimeError:
-        return False
-    return True
-
-
 def _replica_count(value: Any) -> int:
     if value is None:
         return 0
@@ -966,33 +960,6 @@ def _format_knowledge_cutoff(value: KnowledgeCutoff) -> str:
     return value.isoformat()
 
 
-async def _run_in_worker_thread(
-    func: Callable[..., Any], *args: Any, **kwargs: Any
-) -> Any:
-    loop = asyncio.get_running_loop()
-    future: asyncio.Future[Any] = loop.create_future()
-    context = contextvars.copy_context()
-
-    def complete_with_result(value: Any) -> None:
-        if not future.cancelled():
-            future.set_result(value)
-
-    def complete_with_exception(exc: BaseException) -> None:
-        if not future.cancelled():
-            future.set_exception(exc)
-
-    def run() -> None:
-        try:
-            value = context.run(func, *args, **kwargs)
-        except BaseException as exc:
-            loop.call_soon_threadsafe(complete_with_exception, exc)
-        else:
-            loop.call_soon_threadsafe(complete_with_result, value)
-
-    threading.Thread(target=run, daemon=True).start()
-    return await future
-
-
 def _remote_call_error_message(error: BaseException) -> str:
     """Return a best-effort transport error string without assuming error type."""
     details = None
@@ -1358,16 +1325,6 @@ class FunctionCallHandle:
             await asyncio.to_thread(self._resubmit)
 
 
-async def _gather_async(
-    handles: list[FunctionCallHandle],
-    *,
-    timeout: float | None = None,
-) -> list[Any]:
-    return list(
-        await asyncio.gather(*(handle.get(timeout=timeout) for handle in handles))
-    )
-
-
 def gather(
     handles: typing.Iterable[FunctionCallHandle],
     *,
@@ -1378,18 +1335,7 @@ def gather(
     In synchronous code this blocks and returns ``list[Any]``. Inside a running
     event loop it returns an awaitable, matching :meth:`FunctionCallHandle.get`.
     """
-    handle_list = list(handles)
-    for i, handle in enumerate(handle_list):
-        if not callable(getattr(handle, "get", None)):
-            raise TypeError(
-                f"gather() expects deferred-call handles from .defer(), but item "
-                f"{i} is a {type(handle).__name__}. .remote() runs the call and "
-                f"returns its result, not a handle — use .defer() to fan out, e.g. "
-                f"gather(fn.defer(x) for x in xs)."
-            )
-    if _has_running_event_loop():
-        return _gather_async(handle_list, timeout=timeout)
-    return asyncio.run(_gather_async(handle_list, timeout=timeout))
+    return gather_handles(handles, timeout=timeout)
 
 
 def _source_text_for_deploy(source_file: str) -> str: