wehub/openai--openai-agents-python
1
0
Fork 0
Code Issues Pull Requests Actions 1 Deployments Models Agent Notes Packages Projects Releases Wiki Activity

chore: import upstream snapshot with attribution

Browse Source
This commit is contained in:
wehub-resource-sync
2026-07-13 12:39:17 +08:00
commit 4ed4e9ff99
1368 changed files with 334957 additions and 0 deletions
Download Patch File Download Diff File Expand all files Collapse all files
examples/sandbox/docker/mounts/__init__.py
+1
View File
@@ -0,0 +1 @@
# Docker mount smoke-test examples.
examples/sandbox/docker/mounts/azure_mount_read_write.py
+84
View File
@@ -0,0 +1,84 @@
from __future__ import annotations
import asyncio
import os
import sys
from pathlib import Path
if __package__ is None or __package__ == "":
sys.path.insert(0, str(Path(__file__).resolve().parents[4]))
from agents.sandbox.entries import (
AzureBlobMount,
DockerVolumeMountStrategy,
FuseMountPattern,
InContainerMountStrategy,
RcloneMountPattern,
)
from examples.sandbox.docker.mounts.mount_smoke import (
MountSmokeCase,
require_env,
run_mount_smoke_test,
)
def _mount_cases() -> list[MountSmokeCase]:
account = require_env("AZURE_STORAGE_ACCOUNT")
container = require_env("AZURE_STORAGE_CONTAINER")
endpoint = os.getenv("AZURE_STORAGE_ENDPOINT")
identity_client_id = os.getenv("AZURE_CLIENT_ID")
account_key = os.getenv("AZURE_STORAGE_ACCOUNT_KEY")
return [
MountSmokeCase(
name="docker_volume/rclone",
mount_dir="azure-docker-volume-rclone",
mount=AzureBlobMount(
account=account,
container=container,
endpoint=endpoint,
identity_client_id=identity_client_id,
account_key=account_key,
mount_strategy=DockerVolumeMountStrategy(driver="rclone"),
read_only=False,
),
),
MountSmokeCase(
name="in_container/rclone",
mount_dir="azure-in-container-rclone",
mount=AzureBlobMount(
account=account,
container=container,
endpoint=endpoint,
identity_client_id=identity_client_id,
account_key=account_key,
mount_strategy=InContainerMountStrategy(pattern=RcloneMountPattern()),
read_only=False,
),
),
MountSmokeCase(
name="in_container/fuse",
mount_dir="azure-in-container-fuse",
mount=AzureBlobMount(
account=account,
container=container,
endpoint=endpoint,
identity_client_id=identity_client_id,
account_key=account_key,
mount_strategy=InContainerMountStrategy(pattern=FuseMountPattern()),
read_only=False,
),
),
]
async def main() -> None:
await run_mount_smoke_test(
provider="azure",
agent_name="Azure Blob Mount Smoke Test",
mount_cases=_mount_cases(),
)
if __name__ == "__main__":
asyncio.run(main())
examples/sandbox/docker/mounts/gcs_mount_read_write.py
+100
View File
@@ -0,0 +1,100 @@
from __future__ import annotations
import asyncio
import os
import sys
from pathlib import Path
if __package__ is None or __package__ == "":
sys.path.insert(0, str(Path(__file__).resolve().parents[4]))
from agents.sandbox.entries import (
DockerVolumeMountStrategy,
GCSMount,
InContainerMountStrategy,
MountpointMountPattern,
RcloneMountPattern,
)
from examples.sandbox.docker.mounts.mount_smoke import (
MountSmokeCase,
require_env,
run_mount_smoke_test,
)
def _mount_cases() -> list[MountSmokeCase]:
bucket = require_env("GCS_MOUNT_BUCKET")
access_id = os.getenv("GCS_ACCESS_ID")
secret_access_key = os.getenv("GCS_SECRET_ACCESS_KEY")
prefix = os.getenv("GCS_MOUNT_PREFIX")
region = os.getenv("GCS_REGION")
endpoint_url = os.getenv("GCS_ENDPOINT_URL")
service_account_file = os.getenv("GCS_SERVICE_ACCOUNT_FILE")
service_account_credentials = os.getenv("GCS_SERVICE_ACCOUNT_CREDENTIALS")
access_token = os.getenv("GCS_ACCESS_TOKEN")
return [
MountSmokeCase(
name="docker_volume/rclone",
mount_dir="gcs-docker-volume-rclone",
mount=GCSMount(
bucket=bucket,
access_id=access_id,
secret_access_key=secret_access_key,
prefix=prefix,
region=region,
endpoint_url=endpoint_url,
service_account_file=service_account_file,
service_account_credentials=service_account_credentials,
access_token=access_token,
mount_strategy=DockerVolumeMountStrategy(driver="rclone"),
read_only=False,
),
),
MountSmokeCase(
name="in_container/rclone",
mount_dir="gcs-in-container-rclone",
mount=GCSMount(
bucket=bucket,
access_id=access_id,
secret_access_key=secret_access_key,
prefix=prefix,
region=region,
endpoint_url=endpoint_url,
service_account_file=service_account_file,
service_account_credentials=service_account_credentials,
access_token=access_token,
mount_strategy=InContainerMountStrategy(pattern=RcloneMountPattern()),
read_only=False,
),
),
MountSmokeCase(
name="in_container/mountpoint",
mount_dir="gcs-in-container-mountpoint",
mount=GCSMount(
bucket=bucket,
access_id=access_id,
secret_access_key=secret_access_key,
prefix=prefix,
region=region,
endpoint_url=endpoint_url,
service_account_file=service_account_file,
service_account_credentials=service_account_credentials,
access_token=access_token,
mount_strategy=InContainerMountStrategy(pattern=MountpointMountPattern()),
read_only=False,
),
),
]
async def main() -> None:
await run_mount_smoke_test(
provider="gcs",
agent_name="GCS Mount Smoke Test",
mount_cases=_mount_cases(),
)
if __name__ == "__main__":
asyncio.run(main())
examples/sandbox/docker/mounts/mount_smoke.py
+153
View File
@@ -0,0 +1,153 @@
from __future__ import annotations
import os
import uuid
from collections.abc import Sequence
from dataclasses import dataclass
from pathlib import Path
import docker # type: ignore[import-untyped]
from agents import ModelSettings, Runner
from agents.run import RunConfig
from agents.sandbox import Manifest, SandboxAgent, SandboxRunConfig
from agents.sandbox.entries import Mount
from agents.sandbox.errors import MountCommandError
from agents.sandbox.sandboxes.docker import (
DockerSandboxClient,
DockerSandboxClientOptions,
)
from agents.sandbox.session.sandbox_session import SandboxSession
from examples.sandbox.misc.workspace_shell import WorkspaceShellCapability
IMAGE = "agents-sandbox-docker-mount-example:latest"
DOCKERFILE = Path(__file__).resolve().parent.parent / "Dockerfile.mount"
@dataclass(frozen=True)
class MountSmokeCase:
"""One mount target to verify inside a shared Docker sandbox session."""
name: str
mount_dir: str
mount: Mount
def require_env(name: str) -> str:
"""Return a required environment variable or stop with a clear message."""
value = os.getenv(name)
if not value:
raise SystemExit(f"Missing required environment variable: {name}")
return value
def ensure_mount_image() -> None:
"""Build the Docker image with the in-container mount CLIs if it is missing."""
docker_client = docker.from_env()
try:
docker_client.images.get(IMAGE)
return
except docker.errors.ImageNotFound:
pass
print(f"building {IMAGE} from {DOCKERFILE.name}...")
docker_client.images.build(
path=str(DOCKERFILE.parent),
dockerfile=DOCKERFILE.name,
tag=IMAGE,
rm=True,
)
def build_agent(name: str, manifest: Manifest) -> SandboxAgent:
"""Create the minimal shell-only agent used by these mount smoke tests."""
return SandboxAgent(
name=name,
model=os.getenv("OPENAI_MODEL", "gpt-5.6-sol"),
instructions=(
"Use the shell tool only. Write the requested exact content to the requested exact "
"path, read the file back with cat, and then reply with only `done`."
),
default_manifest=manifest,
capabilities=[WorkspaceShellCapability()],
model_settings=ModelSettings(tool_choice="required"),
)
async def _check_case(
sandbox: SandboxSession,
agent: SandboxAgent,
provider: str,
mount_case: MountSmokeCase,
) -> None:
key = f"docker-{provider}-mount-example-{mount_case.mount_dir}-{uuid.uuid4().hex}.txt"
path = Path("/workspace") / mount_case.mount_dir / key
expected = f"hello from {mount_case.name} {uuid.uuid4().hex}"
result = await Runner.run(
agent,
(
f"Write exactly this content to {path} with `printf %s`, not `echo`: {expected}\n"
f"Then read {path} back with cat."
),
run_config=RunConfig(
sandbox=SandboxRunConfig(session=sandbox),
workflow_name=f"Docker {provider} mount smoke test ({mount_case.name})",
),
)
print(result.final_output)
read_back = await sandbox.read(path)
actual = read_back.read()
if not isinstance(actual, bytes):
raise TypeError(f"Expected bytes from session.read(), got {type(actual)!r}")
actual_text = actual.decode("utf-8")
if actual_text == f"{expected}\n":
actual_text = expected
assert actual_text == expected, f"read back {actual!r}, expected {expected!r}"
print(f"{mount_case.name}: ok")
async def run_mount_smoke_test(
*,
provider: str,
agent_name: str,
mount_cases: Sequence[MountSmokeCase],
) -> None:
"""Start one Docker sandbox session and verify read/write on every mount target."""
ensure_mount_image()
manifest = Manifest(
entries={mount_case.mount_dir: mount_case.mount for mount_case in mount_cases},
)
agent = build_agent(agent_name, manifest)
client = DockerSandboxClient(docker.from_env())
try:
sandbox = await client.create(
manifest=manifest,
options=DockerSandboxClientOptions(image=IMAGE),
)
except docker.errors.NotFound as exc:
if 'plugin "rclone" not found' in str(exc):
raise SystemExit("rclone Docker volume plugin not found") from exc
raise
try:
await sandbox.start()
except MountCommandError as exc:
print(f"mount command: {exc.context.get('command')}")
print(f"mount stderr: {exc.context.get('stderr')}")
raise
try:
for mount_case in mount_cases:
await _check_case(sandbox, agent, provider, mount_case)
finally:
await client.delete(sandbox)
examples/sandbox/docker/mounts/s3_files_mount_read_write.py
+72
View File
@@ -0,0 +1,72 @@
"""Smoke-test an Amazon S3 Files file-system mount in Docker.
Required:
S3_FILES_FILE_SYSTEM_ID=fs-...
Common optional settings:
S3_FILES_MOUNT_TARGET_IP=10.0.0.123
AWS_REGION=us-east-1
S3_FILES_ACCESS_POINT=fsap-...
S3_FILES_SUBPATH=/path/in/file-system
Example:
S3_FILES_FILE_SYSTEM_ID=fs-... \
S3_FILES_MOUNT_TARGET_IP=10.0.0.123 \
AWS_REGION=us-east-1 \
uv run python examples/sandbox/docker/mounts/s3_files_mount_read_write.py
"""
from __future__ import annotations
import asyncio
import os
import sys
from pathlib import Path
if __package__ is None or __package__ == "":
sys.path.insert(0, str(Path(__file__).resolve().parents[4]))
from agents.sandbox.entries import (
InContainerMountStrategy,
S3FilesMount,
S3FilesMountPattern,
)
from examples.sandbox.docker.mounts.mount_smoke import (
MountSmokeCase,
require_env,
run_mount_smoke_test,
)
def _mount_cases() -> list[MountSmokeCase]:
file_system_id = require_env("S3_FILES_FILE_SYSTEM_ID")
return [
MountSmokeCase(
name="in_container/s3files",
mount_dir="s3-files-in-container",
mount=S3FilesMount(
file_system_id=file_system_id,
subpath=os.getenv("S3_FILES_SUBPATH"),
mount_target_ip=os.getenv("S3_FILES_MOUNT_TARGET_IP"),
access_point=os.getenv("S3_FILES_ACCESS_POINT"),
region=os.getenv("AWS_REGION") or os.getenv("AWS_DEFAULT_REGION"),
mount_strategy=InContainerMountStrategy(pattern=S3FilesMountPattern()),
read_only=False,
),
)
]
async def main() -> None:
await run_mount_smoke_test(
provider="s3-files",
agent_name="S3 Files Mount Smoke Test",
mount_cases=_mount_cases(),
)
if __name__ == "__main__":
asyncio.run(main())
examples/sandbox/docker/mounts/s3_mount_read_write.py
+85
View File
@@ -0,0 +1,85 @@
from __future__ import annotations
import asyncio
import os
import sys
from pathlib import Path
if __package__ is None or __package__ == "":
sys.path.insert(0, str(Path(__file__).resolve().parents[4]))
from agents.sandbox.entries import (
DockerVolumeMountStrategy,
InContainerMountStrategy,
MountpointMountPattern,
RcloneMountPattern,
S3Mount,
)
from examples.sandbox.docker.mounts.mount_smoke import (
MountSmokeCase,
require_env,
run_mount_smoke_test,
)
def _mount_cases() -> list[MountSmokeCase]:
bucket = require_env("S3_MOUNT_BUCKET")
return [
MountSmokeCase(
name="docker_volume/rclone",
mount_dir="s3-docker-volume-rclone",
mount=S3Mount(
bucket=bucket,
access_key_id=os.getenv("AWS_ACCESS_KEY_ID"),
secret_access_key=os.getenv("AWS_SECRET_ACCESS_KEY"),
session_token=os.getenv("AWS_SESSION_TOKEN"),
prefix=os.getenv("S3_MOUNT_PREFIX"),
region=os.getenv("AWS_REGION") or os.getenv("AWS_DEFAULT_REGION"),
endpoint_url=os.getenv("S3_ENDPOINT_URL"),
mount_strategy=DockerVolumeMountStrategy(driver="rclone"),
read_only=False,
),
),
MountSmokeCase(
name="in_container/rclone",
mount_dir="s3-in-container-rclone",
mount=S3Mount(
bucket=bucket,
access_key_id=os.getenv("AWS_ACCESS_KEY_ID"),
secret_access_key=os.getenv("AWS_SECRET_ACCESS_KEY"),
session_token=os.getenv("AWS_SESSION_TOKEN"),
prefix=os.getenv("S3_MOUNT_PREFIX"),
region=os.getenv("AWS_REGION") or os.getenv("AWS_DEFAULT_REGION"),
endpoint_url=os.getenv("S3_ENDPOINT_URL"),
mount_strategy=InContainerMountStrategy(pattern=RcloneMountPattern()),
read_only=False,
),
),
MountSmokeCase(
name="in_container/mountpoint",
mount_dir="s3-in-container-mountpoint",
mount=S3Mount(
bucket=bucket,
access_key_id=os.getenv("AWS_ACCESS_KEY_ID"),
secret_access_key=os.getenv("AWS_SECRET_ACCESS_KEY"),
session_token=os.getenv("AWS_SESSION_TOKEN"),
prefix=os.getenv("S3_MOUNT_PREFIX"),
region=os.getenv("AWS_REGION") or os.getenv("AWS_DEFAULT_REGION"),
endpoint_url=os.getenv("S3_ENDPOINT_URL"),
mount_strategy=InContainerMountStrategy(pattern=MountpointMountPattern()),
read_only=False,
),
),
]
async def main() -> None:
await run_mount_smoke_test(
provider="s3",
agent_name="S3 Mount Smoke Test",
mount_cases=_mount_cases(),
)
if __name__ == "__main__":
asyncio.run(main())