Skip to content

AutoGPT is the vision of accessible AI for everyone, to use and to build on. Our mission is to provide the tools, so that you can focus on what matters.

feat(backend): tier-based workspace file storage limits (#12780)

Nicholas Tindle33fb4bc4dc7b
diff --git a/autogpt_platform/backend/.env.default b/autogpt_platform/backend/.env.default
index 3b6ba6ce12..98710591c4 100644
--- a/autogpt_platform/backend/.env.default
+++ b/autogpt_platform/backend/.env.default
@@ -20,7 +20,7 @@ PRISMA_SCHEMA="postgres/schema.prisma"
## ===== REQUIRED SERVICE CREDENTIALS ===== ##
# Redis Configuration
REDIS_HOST=localhost
-REDIS_PORT=6379
+REDIS_PORT=17000
# REDIS_PASSWORD=
# RabbitMQ Credentials
diff --git a/autogpt_platform/backend/backend/api/features/workspace/routes.py b/autogpt_platform/backend/backend/api/features/workspace/routes.py
index c22cc445c4..8065a7f752 100644
--- a/autogpt_platform/backend/backend/api/features/workspace/routes.py
+++ b/autogpt_platform/backend/backend/api/features/workspace/routes.py
@@ -2,6 +2,7 @@
Workspace API routes for managing user file storage.
"""
+import asyncio
import logging
import os
import re
@@ -14,6 +15,8 @@ from fastapi import Query, UploadFile
from fastapi.responses import Response
from pydantic import BaseModel, Field
+from backend.api.features.store.exceptions import VirusDetectedError, VirusScanError
+from backend.copilot.rate_limit import get_workspace_storage_limit_bytes
from backend.data.workspace import (
WorkspaceFile,
count_workspace_files,
@@ -21,11 +24,9 @@ from backend.data.workspace import (
get_workspace,
get_workspace_file,
get_workspace_total_size,
- soft_delete_workspace_file,
)
from backend.util.settings import Config
-from backend.util.virus_scanner import scan_content_safe
-from backend.util.workspace import WorkspaceManager
+from backend.util.workspace import WorkspaceManager, format_bytes
from backend.util.workspace_storage import get_workspace_storage
@@ -249,66 +250,47 @@ async def upload_file(
# Get or create workspace
workspace = await get_or_create_workspace(user_id)
- # Pre-write storage cap check (soft check — final enforcement is post-write)
- storage_limit_bytes = config.max_workspace_storage_mb * 1024 * 1024
- current_usage = await get_workspace_total_size(workspace.id)
- if storage_limit_bytes and current_usage + len(content) > storage_limit_bytes:
- used_percent = (current_usage / storage_limit_bytes) * 100
- raise fastapi.HTTPException(
- status_code=413,
- detail={
- "message": "Storage limit exceeded",
- "used_bytes": current_usage,
- "limit_bytes": storage_limit_bytes,
- "used_percent": round(used_percent, 1),
- },
- )
-
- # Warn at 80% usage
- if (
- storage_limit_bytes
- and (usage_ratio := (current_usage + len(content)) / storage_limit_bytes) >= 0.8
- ):
- logger.warning(
- f"User {user_id} workspace storage at {usage_ratio * 100:.1f}% "
- f"({current_usage + len(content)} / {storage_limit_bytes} bytes)"
- )
-
- # Virus scan
- await scan_content_safe(content, filename=filename)
-
- # Write file via WorkspaceManager
+ # Write file via WorkspaceManager (handles virus scan, per-file size,
+ # and per-user tier-based storage quota internally).
manager = WorkspaceManager(user_id, workspace.id, session_id)
try:
workspace_file = await manager.write_file(
content, filename, overwrite=overwrite, metadata={"origin": "user-upload"}
)
+ except VirusDetectedError as e:
+ raise fastapi.HTTPException(status_code=400, detail=str(e)) from e
+ except VirusScanError as e:
+ raise fastapi.HTTPException(status_code=500, detail=str(e)) from e
except ValueError as e:
- # write_file raises ValueError for both path-conflict and size-limit
- # cases; map each to its correct HTTP status.
+ # write_file raises ValueError for path-conflict, size-limit, and
+ # storage-quota cases; map each to its correct HTTP status.
message = str(e)
- if message.startswith("File too large"):
+ if message.startswith(("File too large", "Storage limit exceeded")):
raise fastapi.HTTPException(status_code=413, detail=message) from e
raise fastapi.HTTPException(status_code=409, detail=message) from e
# Post-write storage check — eliminates TOCTOU race on the quota.
# If a concurrent upload pushed us over the limit, undo this write.
+ storage_limit_bytes = await get_workspace_storage_limit_bytes(user_id)
new_total = await get_workspace_total_size(workspace.id)
if storage_limit_bytes and new_total > storage_limit_bytes:
try:
- await soft_delete_workspace_file(workspace_file.id, workspace.id)
+ # Route through WorkspaceManager so the storage backend blob is
+ # removed too — soft_delete_workspace_file alone leaks the blob.
+ await manager.delete_file(workspace_file.id)
except Exception as e:
logger.warning(
- f"Failed to soft-delete over-quota file {workspace_file.id} "
+ f"Failed to delete over-quota file {workspace_file.id} "
f"in workspace {workspace.id}: {e}"
)
raise fastapi.HTTPException(
status_code=413,
- detail={
- "message": "Storage limit exceeded (concurrent upload)",
- "used_bytes": new_total,
- "limit_bytes": storage_limit_bytes,
- },
+ detail=(
+ f"Storage limit exceeded. "
+ f"You've used {format_bytes(new_total)} of your "
+ f"{format_bytes(storage_limit_bytes)} quota. "
+ f"Delete some files or upgrade your plan for more storage."
+ ),
)
return UploadFileResponse(
@@ -331,12 +313,13 @@ async def get_storage_usage(
"""
Get storage usage information for the user's workspace.
"""
- config = Config()
workspace = await get_or_create_workspace(user_id)
- used_bytes = await get_workspace_total_size(workspace.id)
- file_count = await count_workspace_files(workspace.id)
- limit_bytes = config.max_workspace_storage_mb * 1024 * 1024
+ used_bytes, file_count, limit_bytes = await asyncio.gather(
+ get_workspace_total_size(workspace.id),
+ count_workspace_files(workspace.id),
+ get_workspace_storage_limit_bytes(user_id),
+ )
return StorageUsageResponse(
used_bytes=used_bytes,
diff --git a/autogpt_platform/backend/backend/api/features/workspace/routes_test.py b/autogpt_platform/backend/backend/api/features/workspace/routes_test.py
index ffc712014f..b5bcbdef8b 100644
--- a/autogpt_platform/backend/backend/api/features/workspace/routes_test.py
+++ b/autogpt_platform/backend/backend/api/features/workspace/routes_test.py
@@ -151,15 +151,16 @@ def test_list_files_null_metadata_coerced_to_empty_dict(
# -- upload_file metadata tests --
+@patch("backend.api.features.workspace.routes.get_workspace_storage_limit_bytes")
@patch("backend.api.features.workspace.routes.get_or_create_workspace")
@patch("backend.api.features.workspace.routes.get_workspace_total_size")
-@patch("backend.api.features.workspace.routes.scan_content_safe")
@patch("backend.api.features.workspace.routes.WorkspaceManager")
def test_upload_passes_user_upload_origin_metadata(
- mock_manager_cls, mock_scan, mock_total_size, mock_get_workspace
+ mock_manager_cls, mock_total_size, mock_get_workspace, mock_storage_limit
):
mock_get_workspace.return_value = _make_workspace()
mock_total_size.return_value = 100
+ mock_storage_limit.return_value = 250 * 1024 * 1024
written = _make_file(id="new-file", name="doc.pdf")
mock_instance = AsyncMock()
mock_instance.write_file.return_value = written
@@ -178,10 +179,9 @@ def test_upload_passes_user_upload_origin_metadata(
@patch("backend.api.features.workspace.routes.get_or_create_workspace")
@patch("backend.api.features.workspace.routes.get_workspace_total_size")
-@patch("backend.api.features.workspace.routes.scan_content_safe")
@patch("backend.api.features.workspace.routes.WorkspaceManager")
def test_upload_returns_409_on_file_conflict(
- mock_manager_cls, mock_scan, mock_total_size, mock_get_workspace
+ mock_manager_cls, mock_total_size, mock_get_workspace
):
mock_get_workspace.return_value = _make_workspace()
mock_total_size.return_value = 100
@@ -234,8 +234,8 @@ def test_upload_happy_path(mocker):
return_value=0,
)
mocker.patch(
- "backend.api.features.workspace.routes.scan_content_safe",
- return_value=None,
+ "backend.api.features.workspace.routes.get_workspace_storage_limit_bytes",
+ return_value=250 * 1024 * 1024,
)
mock_manager = mocker.MagicMock()
mock_manager.write_file = mocker.AsyncMock(return_value=_MOCK_FILE)
@@ -256,20 +256,24 @@ def test_upload_exceeds_max_file_size(mocker):
"""Files larger than max_file_size_mb should be rejected with 413."""
cfg = mocker.patch("backend.api.features.workspace.routes.Config")
cfg.return_value.max_file_size_mb = 0 # 0 MB → any content is too big
- cfg.return_value.max_workspace_storage_mb = 500
response = _upload(content=b"x" * 1024)
assert response.status_code == 413
def test_upload_storage_quota_exceeded(mocker):
+ """WorkspaceManager.write_file raises ValueError when quota exceeded → 413."""
mocker.patch(
"backend.api.features.workspace.routes.get_or_create_workspace",
return_value=_make_workspace(),
)
+ mock_manager = mocker.MagicMock()
+ mock_manager.write_file = mocker.AsyncMock(
+ side_effect=ValueError("Storage limit exceeded: 500 MB used of 250 MB (200.0%)")
+ )
mocker.patch(
- "backend.api.features.workspace.routes.get_workspace_total_size",
- return_value=500 * 1024 * 1024,
+ "backend.api.features.workspace.routes.WorkspaceManager",
+ return_value=mock_manager,
)
response = _upload()
@@ -278,33 +282,33 @@ def test_upload_storage_quota_exceeded(mocker):
def test_upload_post_write_quota_race(mocker):
- """Concurrent upload tipping over limit after write should soft-delete + 413."""
+ """Concurrent upload tipping over limit after write should delete + 413."""
mocker.patch(
"backend.api.features.workspace.routes.get_or_create_workspace",
return_value=_make_workspace(),
)
+ # Post-write total exceeds the tier-based limit (250 MB for FREE).
mocker.patch(
"backend.api.features.workspace.routes.get_workspace_total_size",
- side_effect=[0, 600 * 1024 * 1024],
+ return_value=600 * 1024 * 1024,
)
mocker.patch(
- "backend.api.features.workspace.routes.scan_content_safe",
- return_value=None,
+ "backend.api.features.workspace.routes.get_workspace_storage_limit_bytes",
+ return_value=250 * 1024 * 1024,
)
mock_manager = mocker.MagicMock()
mock_manager.write_file = mocker.AsyncMock(return_value=_MOCK_FILE)
+ mock_manager.delete_file = mocker.AsyncMock(return_value=True)
mocker.patch(
"backend.api.features.workspace.routes.WorkspaceManager",
return_value=mock_manager,
)
- mock_delete = mocker.patch(
- "backend.api.features.workspace.routes.soft_delete_workspace_file",
- return_value=None,
- )
response = _upload()
assert response.status_code == 413
- mock_delete.assert_called_once_with("file-aaa-bbb", "ws-001")
+ # Rollback must go through manager.delete_file so the storage blob is removed,
+ # not just soft_delete_workspace_file (which would orphan the blob).
+ mock_manager.delete_file.assert_awaited_once_with("file-aaa-bbb")
def test_upload_any_extension(mocker):
@@ -318,8 +322,8 @@ def test_upload_any_extension(mocker):
return_value=0,
)
mocker.patch(
- "backend.api.features.workspace.routes.scan_content_safe",
- return_value=None,
+ "backend.api.features.workspace.routes.get_workspace_storage_limit_bytes",
+ return_value=250 * 1024 * 1024,
)
mock_manager = mocker.MagicMock()
mock_manager.write_file = mocker.AsyncMock(return_value=_MOCK_FILE)
@@ -333,23 +337,17 @@ def test_upload_any_extension(mocker):
def test_upload_blocked_by_virus_scan(mocker):
- """Files flagged by ClamAV should be rejected and never written to storage."""
+ """Files flagged by ClamAV should be rejected via WorkspaceManager."""
from backend.api.features.store.exceptions import VirusDetectedError
mocker.patch(
"backend.api.features.workspace.routes.get_or_create_workspace",
return_value=_make_workspace(),
)
- mocker.patch(
- "backend.api.features.workspace.routes.get_workspace_total_size",
- return_value=0,
- )
- mocker.patch(
- "backend.api.features.workspace.routes.scan_content_safe",
+ mock_manager = mocker.MagicMock()
+ mock_manager.write_file = mocker.AsyncMock(
side_effect=VirusDetectedError("Eicar-Test-Signature"),
)
- mock_manager = mocker.MagicMock()
- mock_manager.write_file = mocker.AsyncMock(return_value=_MOCK_FILE)
mocker.patch(
"backend.api.features.workspace.routes.WorkspaceManager",
return_value=mock_manager,
@@ -357,7 +355,6 @@ def test_upload_blocked_by_virus_scan(mocker):
response = _upload(filename="evil.exe", content=b"X5O!P%@AP...")
assert response.status_code == 400
- mock_manager.write_file.assert_not_called()
def test_upload_file_without_extension(mocker):
@@ -371,8 +368,8 @@ def test_upload_file_without_extension(mocker):
return_value=0,
)
mocker.patch(
- "backend.api.features.workspace.routes.scan_content_safe",
- return_value=None,
+ "backend.api.features.workspace.routes.get_workspace_storage_limit_bytes",
+ return_value=250 * 1024 * 1024,
)
mock_manager = mocker.MagicMock()
mock_manager.write_file = mocker.AsyncMock(return_value=_MOCK_FILE)
@@ -402,8 +399,8 @@ def test_upload_strips_path_components(mocker):
return_value=0,
)
mocker.patch(
- "backend.api.features.workspace.routes.scan_content_safe",
- return_value=None,
+ "backend.api.features.workspace.routes.get_workspace_storage_limit_bytes",
+ return_value=250 * 1024 * 1024,
)
mock_manager = mocker.MagicMock()
mock_manager.write_file = mocker.AsyncMock(return_value=_MOCK_FILE)
@@ -488,14 +485,6 @@ def test_upload_write_file_too_large_returns_413(mocker):
"backend.api.features.workspace.routes.get_or_create_workspace",
return_value=_make_workspace(),
)
- mocker.patch(
- "backend.api.features.workspace.routes.get_workspace_total_size",
- return_value=0,
- )
- mocker.patch(
- "backend.api.features.workspace.routes.scan_content_safe",
- return_value=None,
- )
mock_manager = mocker.MagicMock()
mock_manager.write_file = mocker.AsyncMock(
side_effect=ValueError("File too large: 900 bytes exceeds 1MB limit")
@@ -516,14 +505,6 @@ def test_upload_write_file_conflict_returns_409(mocker):
"backend.api.features.workspace.routes.get_or_create_workspace",
return_value=_make_workspace(),
)
- mocker.patch(
- "backend.api.features.workspace.routes.get_workspace_total_size",
- return_value=0,
- )
- mocker.patch(
- "backend.api.features.workspace.routes.scan_content_safe",
- return_value=None,
- )
mock_manager = mocker.MagicMock()
mock_manager.write_file = mocker.AsyncMock(
side_effect=ValueError("File already exists at path: /sessions/x/a.txt")
@@ -602,6 +583,54 @@ def test_list_files_offset_is_echoed_back(mock_manager_cls, mock_get_workspace):
)
+def test_upload_virus_scan_infrastructure_error_returns_500(mocker):
+ """VirusScanError (ClamAV outage) should return 500, not 409."""
+ from backend.api.features.store.exceptions import VirusScanError
+
+ mocker.patch(
+ "backend.api.features.workspace.routes.get_or_create_workspace",
+ return_value=_make_workspace(),
+ )
+ mock_manager = mocker.MagicMock()
+ mock_manager.write_file = mocker.AsyncMock(
+ side_effect=VirusScanError("ClamAV connection refused"),
+ )
+ mocker.patch(
+ "backend.api.features.workspace.routes.WorkspaceManager",
+ return_value=mock_manager,
+ )
+
+ response = _upload()
+ assert response.status_code == 500
+
+
+def test_get_storage_usage_returns_tier_based_limit(mocker):
+ """get_storage_usage should return the user's tier-based limit, not a static config."""
+ mocker.patch(
+ "backend.api.features.workspace.routes.get_or_create_workspace",
+ return_value=_make_workspace(),
+ )
+ mocker.patch(
+ "backend.api.features.workspace.routes.get_workspace_total_size",
+ return_value=100 * 1024 * 1024, # 100 MB used
+ )
+ mocker.patch(
+ "backend.api.features.workspace.routes.count_workspace_files",
+ return_value=5,
+ )
+ mocker.patch(
+ "backend.api.features.workspace.routes.get_workspace_storage_limit_bytes",
+ return_value=1024 * 1024 * 1024, # 1 GB (PRO tier)
+ )
+
+ response = client.get("/storage/usage")
+ assert response.status_code == 200
+ data = response.json()
+ assert data["limit_bytes"] == 1024 * 1024 * 1024
+ assert data["used_bytes"] == 100 * 1024 * 1024
+ assert data["file_count"] == 5
+
+
# -- _sanitize_filename_for_header tests --
diff --git a/autogpt_platform/backend/backend/copilot/rate_limit.py b/autogpt_platform/backend/backend/copilot/rate_limit.py
index ca99346725..f0d244b57b 100644
--- a/autogpt_platform/backend/backend/copilot/rate_limit.py
+++ b/autogpt_platform/backend/backend/copilot/rate_limit.py
@@ -111,6 +111,19 @@ TIER_MULTIPLIERS = _DEFAULT_TIER_MULTIPLIERS
DEFAULT_TIER = SubscriptionTier.NO_TIER
+# Per-tier workspace storage caps in MB. NO_TIER keeps the same baseline as
+# BASIC so users who cancel retain a small quota and see a real overage cap,
+# while LaunchDarkly can still tune tiers without a deploy.
+_DEFAULT_TIER_WORKSPACE_STORAGE_MB: dict[SubscriptionTier, int] = {
+ SubscriptionTier.NO_TIER: 250, # 250 MB
+ SubscriptionTier.BASIC: 250, # 250 MB
+ SubscriptionTier.PRO: 1024, # 1 GB
+ SubscriptionTier.MAX: 5 * 1024, # 5 GB
+ SubscriptionTier.BUSINESS: 15 * 1024, # 15 GB
+ SubscriptionTier.ENTERPRISE: 15 * 1024, # 15 GB
+}
+
+
@cached(ttl_seconds=60, maxsize=1, cache_none=False)
async def _fetch_tier_multipliers_flag() -> dict[SubscriptionTier, float] | None:
"""Fetch the ``copilot-tier-multipliers`` LD flag and parse it.
@@ -232,6 +245,81 @@ async def get_tier_multipliers() -> dict[str, float]:
return {tier.value: multiplier for tier, multiplier in merged.items()}
+@cached(ttl_seconds=60, maxsize=1, cache_none=False)
+async def _fetch_workspace_storage_limits_flag() -> dict[SubscriptionTier, int] | None:
+ """Fetch the ``copilot-tier-workspace-storage-limits`` LD flag and parse it.
+
+ Returns a sparse ``{tier: megabytes}`` map built from whichever keys are
+ valid in the flag payload, or ``None`` when the flag is unset / invalid /
+ LD is unavailable. Callers merge whatever survives into
+ :data:`_DEFAULT_TIER_WORKSPACE_STORAGE_MB`.
+
+ The LD value is expected to be a JSON object keyed by tier enum name
+ (``{"NO_TIER": 250, "PRO": 1024, "BUSINESS": 15360}``). Non-int or
+ negative values are skipped so a broken key degrades to the code default
+ instead of wiping out the limit.
+ """
+ # Lazy import: rate_limit -> feature_flag -> settings -> ... -> rate_limit.
+ from backend.util.feature_flag import Flag, get_feature_flag_value
+
+ raw = await get_feature_flag_value(
+ Flag.COPILOT_TIER_WORKSPACE_STORAGE_LIMITS.value, "system", None
+ )
+ if raw is None:
+ return None
+ if not isinstance(raw, dict):
+ logger.warning(
+ "Invalid LD value for copilot-tier-workspace-storage-limits "
+ "(expected JSON object): %r",
+ raw,
+ )
+ return None
+
+ parsed: dict[SubscriptionTier, int] = {}
+ for key, value in raw.items():
+ try:
+ tier = SubscriptionTier(key)
+ except ValueError:
+ continue
+ if isinstance(value, bool) or not isinstance(value, int):
+ logger.warning(
+ "Invalid LD value for copilot-tier-workspace-storage-limits[%s]: %r",
+ key,
+ value,
+ )
+ continue
+ if value <= 0:
+ logger.warning(
+ "Non-positive LD value for copilot-tier-workspace-storage-limits[%s]: %r",
+ key,
+ value,
+ )
+ continue
+ parsed[tier] = value
+ return parsed or None
+
+
+async def get_workspace_storage_limits_mb() -> dict[str, int]:
+ """Return the effective ``{tier_value: megabytes}`` workspace limit map.
+
+ Honours the ``copilot-tier-workspace-storage-limits`` LD flag when set;
+ missing tiers inherit :data:`_DEFAULT_TIER_WORKSPACE_STORAGE_MB`.
+ Unparseable flag values or LD fetch failures fall back to the defaults.
+ """
+ try:
+ override = await _fetch_workspace_storage_limits_flag()
+ except Exception:
+ logger.warning(
+ "get_workspace_storage_limits_mb: LD lookup failed", exc_info=True
+ )
+ override = None
+
+ merged: dict[SubscriptionTier, int] = dict(_DEFAULT_TIER_WORKSPACE_STORAGE_MB)
+ if override:
+ merged.update(override)
+ return {tier.value: megabytes for tier, megabytes in merged.items()}
+
+
class UsageWindow(BaseModel):
"""Usage within a single time window.
@@ -661,6 +749,19 @@ get_user_tier.cache_clear = _fetch_user_tier.cache_clear # type: ignore[attr-de
get_user_tier.cache_delete = _fetch_user_tier.cache_delete # type: ignore[attr-defined]
+async def get_workspace_storage_limit_bytes(user_id: str) -> int:
+ """Return the workspace storage cap in bytes for the user's subscription tier."""
+ tier = await get_user_tier(user_id)
+ limits_mb = await get_workspace_storage_limits_mb()
+ tier_key = getattr(tier, "value", str(tier))
+ fallback_mb = limits_mb.get(
+ DEFAULT_TIER.value,
+ _DEFAULT_TIER_WORKSPACE_STORAGE_MB[DEFAULT_TIER],
+ )
+ mb = limits_mb.get(tier_key, fallback_mb)
+ return mb * 1024 * 1024
+
+
async def set_user_tier(user_id: str, tier: SubscriptionTier) -> None:
"""Persist the user's rate-limit tier to the database.
diff --git a/autogpt_platform/backend/backend/copilot/rate_limit_test.py b/autogpt_platform/backend/backend/copilot/rate_limit_test.py
index 5bfdf80eef..e5033ac30e 100644
--- a/autogpt_platform/backend/backend/copilot/rate_limit_test.py
+++ b/autogpt_platform/backend/backend/copilot/rate_limit_test.py
@@ -8,6 +8,7 @@ from redis.exceptions import RedisError
from .rate_limit import (
_DEFAULT_TIER_MULTIPLIERS,
+ _DEFAULT_TIER_WORKSPACE_STORAGE_MB,
DEFAULT_TIER,
TIER_MULTIPLIERS,
CoPilotUsageStatus,
@@ -18,6 +19,7 @@ from .rate_limit import (
_daily_reset_time,
_fetch_cost_limits_flag,
_fetch_tier_multipliers_flag,
+ _fetch_workspace_storage_limits_flag,
_weekly_key,
_weekly_reset_time,
acquire_reset_lock,
@@ -27,6 +29,8 @@ from .rate_limit import (
get_tier_multipliers,
get_usage_status,
get_user_tier,
+ get_workspace_storage_limit_bytes,
+ get_workspace_storage_limits_mb,
increment_daily_reset_count,
record_cost_usage,
release_reset_lock,
@@ -471,6 +475,85 @@ class TestGetTierMultipliers:
assert result == {t.value: m for t, m in _DEFAULT_TIER_MULTIPLIERS.items()}
+class TestGetWorkspaceStorageLimits:
+ @pytest.fixture(autouse=True)
+ def _clear_flag_cache(self):
+ """Clear the LD flag cache between tests so patches don't leak."""
+ _fetch_workspace_storage_limits_flag.cache_clear() # type: ignore[attr-defined]
+
+ @pytest.mark.asyncio
+ async def test_defaults_when_flag_unset(self):
+ """With no LD override, the resolver returns the default map."""
+ with patch(
+ "backend.util.feature_flag.get_feature_flag_value",
+ new_callable=AsyncMock,
+ return_value=None,
+ ):
+ result = await get_workspace_storage_limits_mb()
+ assert result == {
+ t.value: mb for t, mb in _DEFAULT_TIER_WORKSPACE_STORAGE_MB.items()
+ }
+
+ @pytest.mark.asyncio
+ async def test_ld_override(self):
+ """LD override populates targeted tiers; others inherit defaults."""
+ with patch(
+ "backend.util.feature_flag.get_feature_flag_value",
+ new_callable=AsyncMock,
+ return_value={"NO_TIER": 300, "PRO": 2048},
+ ):
+ result = await get_workspace_storage_limits_mb()
+ assert result["NO_TIER"] == 300
+ assert result["PRO"] == 2048
+ assert (
+ result["BASIC"]
+ == _DEFAULT_TIER_WORKSPACE_STORAGE_MB[SubscriptionTier.BASIC]
+ )
+ assert result["MAX"] == _DEFAULT_TIER_WORKSPACE_STORAGE_MB[SubscriptionTier.MAX]
+
+ @pytest.mark.asyncio
+ async def test_invalid_json_falls_back(self):
+ """A non-object LD value falls back to defaults."""
+ with patch(
+ "backend.util.feature_flag.get_feature_flag_value",
+ new_callable=AsyncMock,
+ return_value="broken",
+ ):
+ result = await get_workspace_storage_limits_mb()
+ assert result == {
+ t.value: mb for t, mb in _DEFAULT_TIER_WORKSPACE_STORAGE_MB.items()
+ }
+
+ @pytest.mark.asyncio
+ async def test_unknown_tier_key_and_invalid_values_skipped(self):
+ """Unknown tiers and invalid values degrade to defaults per key."""
+ with patch(
+ "backend.util.feature_flag.get_feature_flag_value",
+ new_callable=AsyncMock,
+ return_value={"NO_TIER": 300, "BOGUS": 999, "MAX": -1, "BUSINESS": "nope"},
+ ):
+ result = await get_workspace_storage_limits_mb()
+ assert result["NO_TIER"] == 300
+ assert result["MAX"] == _DEFAULT_TIER_WORKSPACE_STORAGE_MB[SubscriptionTier.MAX]
+ assert (
+ result["BUSINESS"]
+ == _DEFAULT_TIER_WORKSPACE_STORAGE_MB[SubscriptionTier.BUSINESS]
+ )
+
+ @pytest.mark.asyncio
+ async def test_ld_failure_falls_back(self):
+ """LD lookup raising propagates to defaults, not up the call stack."""
+ with patch(
+ "backend.util.feature_flag.get_feature_flag_value",
+ new_callable=AsyncMock,
+ side_effect=RuntimeError("LD SDK not initialized"),
+ ):
+ result = await get_workspace_storage_limits_mb()
+ assert result == {
+ t.value: mb for t, mb in _DEFAULT_TIER_WORKSPACE_STORAGE_MB.items()
+ }
+
+
# ---------------------------------------------------------------------------
# get_global_rate_limits — LD-flag cost limits parsing
# ---------------------------------------------------------------------------
@@ -1792,3 +1875,83 @@ class TestResetUserUsage:
):
with pytest.raises(RedisError):
await reset_user_usage("user-1")
+
+
+class TestWorkspaceStorageLimits:
+ """Tests for tier-based workspace storage limits."""
+
+ @pytest.fixture(autouse=True)
+ def _clear_flag_cache(self):
+ _fetch_workspace_storage_limits_flag.cache_clear() # type: ignore[attr-defined]
+
+ def test_every_subscription_tier_has_storage_limit(self):
+ """Adding a new SubscriptionTier without a storage limit should fail."""
+ for tier in SubscriptionTier:
+ assert tier in _DEFAULT_TIER_WORKSPACE_STORAGE_MB, (
+ f"SubscriptionTier.{tier.name} has no entry in "
+ f"_DEFAULT_TIER_WORKSPACE_STORAGE_MB — add one"
+ )
+ assert _DEFAULT_TIER_WORKSPACE_STORAGE_MB[tier] > 0
+
+ def test_every_subscription_tier_has_rate_limit_multiplier(self):
+ """Adding a new SubscriptionTier without a rate limit multiplier should fail."""
+ for tier in SubscriptionTier:
+ assert tier in _DEFAULT_TIER_MULTIPLIERS, (
+ f"SubscriptionTier.{tier.name} has no entry in "
+ f"_DEFAULT_TIER_MULTIPLIERS — add one"
+ )
+ if tier == SubscriptionTier.NO_TIER:
+ assert _DEFAULT_TIER_MULTIPLIERS[tier] == 0.0
+ else:
+ assert _DEFAULT_TIER_MULTIPLIERS[tier] > 0
+
+ @pytest.mark.parametrize(
+ "tier,expected_mb",
+ [
+ (SubscriptionTier.NO_TIER, 250),
+ (SubscriptionTier.BASIC, 250),
+ (SubscriptionTier.PRO, 1024),
+ (SubscriptionTier.MAX, 5 * 1024),
+ (SubscriptionTier.BUSINESS, 15 * 1024),
+ (SubscriptionTier.ENTERPRISE, 15 * 1024),
+ ],
+ )
+ def test_tier_workspace_storage_mapping_covers_all_tiers(self, tier, expected_mb):
+ """Every tier has an explicit storage limit in the mapping."""
+ assert tier in _DEFAULT_TIER_WORKSPACE_STORAGE_MB
+ assert _DEFAULT_TIER_WORKSPACE_STORAGE_MB[tier] == expected_mb
+
+ @pytest.mark.asyncio
+ @pytest.mark.parametrize(
+ "tier,expected_bytes",
+ [
+ (SubscriptionTier.NO_TIER, 250 * 1024 * 1024),
+ (SubscriptionTier.BASIC, 250 * 1024 * 1024),
+ (SubscriptionTier.PRO, 1024 * 1024 * 1024),
+ (SubscriptionTier.MAX, 5 * 1024 * 1024 * 1024),
+ (SubscriptionTier.BUSINESS, 15 * 1024 * 1024 * 1024),
+ (SubscriptionTier.ENTERPRISE, 15 * 1024 * 1024 * 1024),
+ ],
+ )
+ async def test_get_workspace_storage_limit_bytes_per_tier(
+ self, tier, expected_bytes
+ ):
+ """get_workspace_storage_limit_bytes returns correct bytes for each tier."""
+ with patch(
+ "backend.copilot.rate_limit.get_user_tier",
+ return_value=tier,
+ ):
+ result = await get_workspace_storage_limit_bytes("user-1")
+ assert result == expected_bytes
+
+ @pytest.mark.asyncio
+ async def test_get_workspace_storage_limit_bytes_defaults_to_default_tier_on_unknown(
+ self,
+ ):
+ """Unknown tier falls back to the default tier limit."""
+ with patch(
+ "backend.copilot.rate_limit.get_user_tier",
+ return_value="UNKNOWN_TIER",
+ ):
+ result = await get_workspace_storage_limit_bytes("user-1")
+ assert result == 250 * 1024 * 1024
diff --git a/autogpt_platform/backend/backend/copilot/tools/workspace_files.py b/autogpt_platform/backend/backend/copilot/tools/workspace_files.py
index a5fe549923..33c676da88 100644
--- a/autogpt_platform/backend/backend/copilot/tools/workspace_files.py
+++ b/autogpt_platform/backend/backend/copilot/tools/workspace_files.py
@@ -8,6 +8,7 @@ from typing import Any, Optional
from pydantic import BaseModel
+from backend.api.features.store.exceptions import VirusDetectedError, VirusScanError
from backend.copilot.context import (
E2B_WORKDIR,
get_current_sandbox,
@@ -19,7 +20,6 @@ from backend.copilot.context import (
from backend.copilot.model import ChatSession
from backend.copilot.tools.sandbox import make_session_path
from backend.util.settings import Config
-from backend.util.virus_scanner import scan_content_safe
from backend.util.workspace import WorkspaceManager
from .base import BaseTool
@@ -837,7 +837,6 @@ class WriteWorkspaceFileTool(BaseTool):
)
try:
- await scan_content_safe(content_bytes, filename=filename)
manager = await get_workspace_manager(user_id, session_id)
rec = await manager.write_file(
content=content_bytes,
@@ -895,8 +894,21 @@ class WriteWorkspaceFileTool(BaseTool):
message=msg,
session_id=session_id,
)
- except ValueError as e:
+ except VirusDetectedError as e:
+ logger.warning(f"Virus detected in uploaded file: {e.threat_name}")
+ return ErrorResponse(message=str(e), session_id=session_id)
+ except VirusScanError as e:
+ logger.error(f"Virus scan infrastructure error: {e}", exc_info=True)
return ErrorResponse(message=str(e), session_id=session_id)
+ except ValueError as e:
+ msg = str(e)
+ if msg.startswith("Storage limit exceeded"):
+ msg += (
+ " Use list_workspace_files to find candidates, then "
+ "delete_workspace_file to free space and retry — or ask "
+ "the user to upgrade their plan."
+ )
+ return ErrorResponse(message=msg, session_id=session_id)
except Exception as e:
logger.error(f"Error writing workspace file: {e}", exc_info=True)
return ErrorResponse(
diff --git a/autogpt_platform/backend/backend/copilot/tools/workspace_files_test.py b/autogpt_platform/backend/backend/copilot/tools/workspace_files_test.py
index 17b7960cdd..de18572d16 100644
--- a/autogpt_platform/backend/backend/copilot/tools/workspace_files_test.py
+++ b/autogpt_platform/backend/backend/copilot/tools/workspace_files_test.py
@@ -623,3 +623,77 @@ async def test_read_workspace_file_no_fallback_when_resolve_succeeds(setup_test_
# Normal workspace path must have produced a content response.
assert isinstance(result, WorkspaceFileContentResponse)
assert base64.b64decode(result.content_base64) == fake_content
+
+
+# ---------------------------------------------------------------------------
+# WriteWorkspaceFileTool exception handling (quota, virus, scan errors)
+# ---------------------------------------------------------------------------
+
+
[email protected](loop_scope="session")
+class TestWriteWorkspaceFileToolErrorHandling:
+ """Verify WriteWorkspaceFileTool returns proper ErrorResponse for exceptions."""
+
+ async def _execute_write(self, side_effect, setup_test_data):
+ """Helper: run WriteWorkspaceFileTool with mocked write_file."""
+ user = setup_test_data["user"]
+ session = make_session(user.id)
+
+ mock_manager = AsyncMock()
+ mock_manager.write_file = AsyncMock(side_effect=side_effect)
+
+ with patch(
+ "backend.copilot.tools.workspace_files.get_workspace_manager",
+ AsyncMock(return_value=mock_manager),
+ ):
+ tool = WriteWorkspaceFileTool()
+ return await tool._execute(
+ user_id=user.id,
+ session=session,
+ filename="test.txt",
+ content="hello",
+ )
+
+ async def test_quota_exceeded_returns_error_response(self, setup_test_data):
+ """Quota exceeded (ValueError) → ErrorResponse with storage message + recovery hint."""
+ result = await self._execute_write(
+ ValueError("Storage limit exceeded: 250 MB used of 250 MB (100.0%)"),
+ setup_test_data,
+ )
+ assert isinstance(result, ErrorResponse)
+ assert "Storage limit exceeded" in result.message
+ # The agent needs an actionable hint so it can offer to clean up rather
+ # than just relaying the error to the user.
+ assert "delete_workspace_file" in result.message
+ assert "list_workspace_files" in result.message
+
+ async def test_virus_detected_returns_error_response(self, setup_test_data):
+ """VirusDetectedError → ErrorResponse with virus message."""
+ from backend.api.features.store.exceptions import VirusDetectedError
+
+ result = await self._execute_write(
+ VirusDetectedError("Eicar-Test-Signature"),
+ setup_test_data,
+ )
+ assert isinstance(result, ErrorResponse)
+ assert "Virus detected" in result.message
+
+ async def test_virus_scan_error_returns_error_response(self, setup_test_data):
+ """VirusScanError (infra failure) → ErrorResponse with scan message."""
+ from backend.api.features.store.exceptions import VirusScanError
+
+ result = await self._execute_write(
+ VirusScanError("ClamAV connection refused"),
+ setup_test_data,
+ )
+ assert isinstance(result, ErrorResponse)
+ assert "ClamAV" in result.message
+
+ async def test_file_conflict_returns_error_response(self, setup_test_data):
+ """File path conflict (ValueError) → ErrorResponse."""
+ result = await self._execute_write(
+ ValueError("File already exists at path: /sessions/abc/test.txt"),
+ setup_test_data,
+ )
+ assert isinstance(result, ErrorResponse)
+ assert "already exists" in result.message
diff --git a/autogpt_platform/backend/backend/data/credit_subscription_test.py b/autogpt_platform/backend/backend/data/credit_subscription_test.py
index 2c3205a10b..05f06621dd 100644
--- a/autogpt_platform/backend/backend/data/credit_subscription_test.py
+++ b/autogpt_platform/backend/backend/data/credit_subscription_test.py
@@ -204,6 +204,68 @@ async def test_sync_subscription_from_stripe_cancelled():
mock_set.assert_awaited_once_with("user-1", SubscriptionTier.NO_TIER)
+async def test_sync_subscription_from_stripe_cancelled_applies_no_tier_storage_limit():
+ """After unsubscribe takes effect, workspace storage resolves against NO_TIER."""
+ from backend.copilot.rate_limit import get_workspace_storage_limit_bytes
+
+ mock_user = _make_user(tier=SubscriptionTier.PRO)
+ stripe_sub = {
+ "id": "sub_old",
+ "customer": "cus_123",
+ "status": "canceled",
+ "items": {"data": []},
+ }
+ empty_list = MagicMock()
+ empty_list.data = []
+ empty_list.has_more = False
+
+ async def _set_tier(_user_id: str, tier: SubscriptionTier) -> None:
+ mock_user.subscriptionTier = tier
+
+ with (
+ patch(
+ "backend.data.credit.User.prisma",
+ return_value=MagicMock(find_first=AsyncMock(return_value=mock_user)),
+ ),
+ patch(
+ "backend.data.credit.stripe.Subscription.list",
+ return_value=empty_list,
+ ),
+ patch(
+ "backend.data.credit.set_subscription_tier",
+ new_callable=AsyncMock,
+ side_effect=_set_tier,
+ ),
+ patch(
+ "backend.copilot.rate_limit.get_user_tier",
+ new_callable=AsyncMock,
+ side_effect=lambda _user_id: mock_user.subscriptionTier,
+ ),
+ patch(
+ "backend.copilot.rate_limit.get_workspace_storage_limits_mb",
+ new_callable=AsyncMock,
+ return_value={
+ "NO_TIER": 250,
+ "BASIC": 500,
+ "PRO": 1024,
+ "MAX": 5 * 1024,
+ "BUSINESS": 15 * 1024,
+ "ENTERPRISE": 15 * 1024,
+ },
+ ),
+ patch.object(
+ get_pending_subscription_change,
+ "cache_delete",
+ ) as mock_pending_cache_delete,
+ ):
+ await sync_subscription_from_stripe(stripe_sub)
+ result = await get_workspace_storage_limit_bytes("user-1")
+
+ assert result == 250 * 1024 * 1024
+ mock_pending_cache_delete.assert_called_once_with("user-1")
+
+
@pytest.mark.asyncio
async def test_sync_subscription_from_stripe_cancelled_but_other_active_sub_exists():
"""Cancelling sub_old must NOT downgrade the user if sub_new is still active.
diff --git a/autogpt_platform/backend/backend/util/feature_flag.py b/autogpt_platform/backend/backend/util/feature_flag.py
index 9c8a592502..ae795fe988 100644
--- a/autogpt_platform/backend/backend/util/feature_flag.py
+++ b/autogpt_platform/backend/backend/util/feature_flag.py
@@ -44,6 +44,7 @@ class Flag(str, Enum):
COPILOT_SDK = "copilot-sdk"
COPILOT_COST_LIMITS = "copilot-cost-limits"
COPILOT_TIER_MULTIPLIERS = "copilot-tier-multipliers"
+ COPILOT_TIER_WORKSPACE_STORAGE_LIMITS = "copilot-tier-workspace-storage-limits"
COPILOT_TIER_STRIPE_PRICES = "copilot-tier-stripe-prices"
GRAPHITI_MEMORY = "graphiti-memory"
# Stripe Product ID for top-up Checkout sessions. When unset (default),
diff --git a/autogpt_platform/backend/backend/util/settings.py b/autogpt_platform/backend/backend/util/settings.py
index 4dc774432e..579f510072 100644
--- a/autogpt_platform/backend/backend/util/settings.py
+++ b/autogpt_platform/backend/backend/util/settings.py
@@ -441,13 +441,6 @@ class Config(UpdateTrackingModel["Config"], BaseSettings):
description="Maximum file size in MB for workspace files (1-1024 MB)",
)
- max_workspace_storage_mb: int = Field(
- default=500,
- ge=1,
- le=10240,
- description="Maximum total workspace storage per user in MB.",
- )
-
# AutoMod configuration
automod_enabled: bool = Field(
default=False,
diff --git a/autogpt_platform/backend/backend/util/workspace.py b/autogpt_platform/backend/backend/util/workspace.py
index 5ec4a5b336..930741a233 100644
--- a/autogpt_platform/backend/backend/util/workspace.py
+++ b/autogpt_platform/backend/backend/util/workspace.py
@@ -5,6 +5,7 @@ This module provides a high-level interface for workspace file operations,
combining the storage backend and database layer.
"""
+import asyncio
import logging
import mimetypes
import uuid
@@ -12,12 +13,28 @@ from typing import Optional
from prisma.errors import UniqueViolationError
+from backend.copilot.rate_limit import get_workspace_storage_limit_bytes
from backend.data.db_accessors import workspace_db
-from backend.data.workspace import WorkspaceFile
+from backend.data.workspace import WorkspaceFile, get_workspace_total_size
from backend.util.settings import Config
from backend.util.virus_scanner import scan_content_safe
from backend.util.workspace_storage import compute_file_checksum, get_workspace_storage
+
+def format_bytes(n: int) -> str:
+ """Format bytes as a human-readable string (e.g. 250 MB, 1.0 GB)."""
+ KB, MB, GB = 1024, 1024**2, 1024**3
+ if n < KB:
+ return f"{n} B"
+ if n < MB:
+ kb = round(n / KB)
+ return f"{n / MB:.1f} MB" if kb >= 1024 else f"{kb} KB"
+ if n < GB:
+ mb = round(n / MB)
+ return f"{n / GB:.1f} GB" if mb >= 1024 else f"{mb} MB"
+ return f"{n / GB:.1f} GB"
+
+
logger = logging.getLogger(__name__)
@@ -175,7 +192,15 @@ class WorkspaceManager:
Created WorkspaceFile instance
Raises:
- ValueError: If file exceeds size limit or path already exists
+ ValueError: If file exceeds size limit, exceeds the user's
+ tier-based storage quota, or path already exists.
+ VirusDetectedError: If the virus scanner flagged the content as
+ malicious. Callers that want a generic failure should still
+ catch ``Exception``, but a specific handler lets you log this
+ as a security event rather than a generic write failure.
+ VirusScanError: If the virus scanner is unreachable or otherwise
+ fails. Distinct from ``VirusDetectedError`` — typically maps
+ to a 5xx response (infrastructure issue, retry-able).
"""
# Enforce file size limit
max_file_size = Config().max_file_size_mb * 1024 * 1024
@@ -185,11 +210,7 @@ class WorkspaceManager:
f"{Config().max_file_size_mb}MB limit"
)
- # Scan here — callers must NOT duplicate this scan.
- # WorkspaceManager owns virus scanning for all persisted files.
- await scan_content_safe(content, filename=filename)
-
- # Determine path with session scoping
+ # Determine path with session scoping (needed before quota check for overwrites)
if path is None:
path = f"/{filename}"
elif not path.startswith("/"):
@@ -198,10 +219,31 @@ class WorkspaceManager:
# Resolve path with session prefix
path = self._resolve_path(path)
- # Check if file exists at path (only error for non-overwrite case)
- # For overwrite=True, we let the write proceed and handle via UniqueViolationError
- # This ensures the new file is written to storage BEFORE the old one is deleted,
- # preventing data loss if the new write fails
+ # Enforce per-user workspace storage quota (tier-based).
+ # For overwrites, subtract the existing file's size so replacing a file
+ # with a same-size or smaller file is not rejected near the cap.
+ storage_limit, current_usage = await asyncio.gather(
+ get_workspace_storage_limit_bytes(self.user_id),
+ get_workspace_total_size(self.workspace_id),
+ )
+ if overwrite:
+ db = workspace_db()
+ existing = await db.get_workspace_file_by_path(self.workspace_id, path)
+ if existing is not None:
+ current_usage = max(0, current_usage - existing.size_bytes)
+
+ projected_usage = current_usage + len(content)
+ if storage_limit > 0 and projected_usage > storage_limit:
+ raise ValueError(
+ f"Storage limit exceeded. "
+ f"You've used {format_bytes(current_usage)} of your "
+ f"{format_bytes(storage_limit)} quota. "
+ f"Delete some files or upgrade your plan for more storage."
+ )
+
+ # Check if file exists at path (only error for non-overwrite case).
+ # Done before virus scanning so a cheap duplicate-path check isn't
+ # blocked by a potentially slow or unavailable scanner.
db = workspace_db()
if not overwrite:
@@ -209,6 +251,10 @@ class WorkspaceManager:
if existing is not None:
raise ValueError(f"File already exists at path: {path}")
+ # Scan here — callers must NOT duplicate this scan.
+ # WorkspaceManager owns virus scanning for all persisted files.
+ await scan_content_safe(content, filename=filename)
+
# Auto-detect MIME type if not provided
if mime_type is None:
mime_type, _ = mimetypes.guess_type(filename)
diff --git a/autogpt_platform/backend/backend/util/workspace_test.py b/autogpt_platform/backend/backend/util/workspace_test.py
index dcdbda648e..676b77d992 100644
--- a/autogpt_platform/backend/backend/util/workspace_test.py
+++ b/autogpt_platform/backend/backend/util/workspace_test.py
@@ -88,6 +88,11 @@ async def test_write_file_no_overwrite_unique_violation_raises_and_cleans_up(
),
patch("backend.util.workspace.workspace_db", return_value=mock_db),
patch("backend.util.workspace.scan_content_safe", new_callable=AsyncMock),
+ patch(
+ "backend.util.workspace.get_workspace_storage_limit_bytes",
+ return_value=250 * 1024 * 1024,
+ ),
+ patch("backend.util.workspace.get_workspace_total_size", return_value=0),
):
with pytest.raises(ValueError, match="File already exists"):
await manager.write_file(
@@ -115,6 +120,11 @@ async def test_write_file_overwrite_conflict_then_retry_succeeds(
),
patch("backend.util.workspace.workspace_db", return_value=mock_db),
patch("backend.util.workspace.scan_content_safe", new_callable=AsyncMock),
+ patch(
+ "backend.util.workspace.get_workspace_storage_limit_bytes",
+ return_value=250 * 1024 * 1024,
+ ),
+ patch("backend.util.workspace.get_workspace_total_size", return_value=0),
patch.object(manager, "delete_file", new_callable=AsyncMock) as mock_delete,
):
result = await manager.write_file(
@@ -148,6 +158,11 @@ async def test_write_file_overwrite_exhausted_retries_raises_and_cleans_up(
),
patch("backend.util.workspace.workspace_db", return_value=mock_db),
patch("backend.util.workspace.scan_content_safe", new_callable=AsyncMock),
+ patch(
+ "backend.util.workspace.get_workspace_storage_limit_bytes",
+ return_value=250 * 1024 * 1024,
+ ),
+ patch("backend.util.workspace.get_workspace_total_size", return_value=0),
patch.object(manager, "delete_file", new_callable=AsyncMock),
):
with pytest.raises(ValueError, match="Unable to overwrite.*concurrent write"):
@@ -156,3 +171,104 @@ async def test_write_file_overwrite_exhausted_retries_raises_and_cleans_up(
)
mock_storage.delete.assert_called_once()
+
+
+async def test_write_file_quota_exceeded_raises_value_error(
+ manager, mock_storage, mock_db
+):
+ """write_file raises ValueError when workspace storage quota is exceeded."""
+ mock_db.get_workspace_file_by_path.return_value = None
+
+ with (
+ patch(
+ "backend.util.workspace.get_workspace_storage",
+ return_value=mock_storage,
+ ),
+ patch("backend.util.workspace.workspace_db", return_value=mock_db),
+ patch(
+ "backend.util.workspace.scan_content_safe", new_callable=AsyncMock
+ ) as mock_scan,
+ patch(
+ "backend.util.workspace.get_workspace_storage_limit_bytes",
+ return_value=250 * 1024 * 1024, # 250 MB limit
+ ),
+ patch(
+ "backend.util.workspace.get_workspace_total_size",
+ return_value=250 * 1024 * 1024, # already at limit
+ ),
+ ):
+ with pytest.raises(ValueError, match="Storage limit exceeded"):
+ await manager.write_file(filename="test.txt", content=b"hello")
+
+ # Quota rejection should short-circuit before expensive virus scan
+ mock_scan.assert_not_called()
+ # Storage should NOT have been written to
+ mock_storage.store.assert_not_called()
+
+
+async def test_write_file_rejects_upload_when_usage_already_exceeds_downgraded_limit(
+ manager, mock_storage, mock_db
+):
+ """Downgrading below current usage should block further uploads until usage drops."""
+ mock_db.get_workspace_file_by_path.return_value = None
+
+ with (
+ patch(
+ "backend.util.workspace.get_workspace_storage",
+ return_value=mock_storage,
+ ),
+ patch("backend.util.workspace.workspace_db", return_value=mock_db),
+ patch(
+ "backend.util.workspace.scan_content_safe", new_callable=AsyncMock
+ ) as mock_scan,
+ patch(
+ "backend.util.workspace.get_workspace_storage_limit_bytes",
+ return_value=250 * 1024 * 1024,
+ ),
+ patch(
+ "backend.util.workspace.get_workspace_total_size",
+ return_value=300 * 1024 * 1024,
+ ),
+ ):
+ with pytest.raises(ValueError, match="Storage limit exceeded"):
+ await manager.write_file(filename="test.txt", content=b"hello")
+
+ mock_scan.assert_not_called()
+ mock_storage.store.assert_not_called()
+
+
+async def test_write_file_overwrite_not_double_counted(manager, mock_storage, mock_db):
+ """Overwriting a file subtracts the old file size from usage check."""
+ existing_file = _make_workspace_file(size_bytes=50)
+ created_file = _make_workspace_file()
+ mock_db.get_workspace_file_by_path.return_value = existing_file
+ mock_db.create_workspace_file.return_value = created_file
+
+ limit_bytes = 100
+ current_usage = 90 # 90 bytes used, 50 of which is the file being replaced
+ content = b"x" * 50 # replacing with same-size file — should succeed
+
+ with (
+ patch(
+ "backend.util.workspace.get_workspace_storage",
+ return_value=mock_storage,
+ ),
+ patch("backend.util.workspace.workspace_db", return_value=mock_db),
+ patch("backend.util.workspace.scan_content_safe", new_callable=AsyncMock),
+ patch(
+ "backend.util.workspace.get_workspace_storage_limit_bytes",
+ return_value=limit_bytes,
+ ),
+ patch(
+ "backend.util.workspace.get_workspace_total_size",
+ return_value=current_usage,
+ ),
+ ):
+ # Should NOT raise — net usage after overwrite is 90 - 50 + 50 = 90, under 100
+ result = await manager.write_file(
+ filename="test.txt", content=content, overwrite=True
+ )
+ assert result == created_file
diff --git a/autogpt_platform/frontend/src/app/(platform)/copilot/components/UsageLimits/UsagePanelContent.tsx b/autogpt_platform/frontend/src/app/(platform)/copilot/components/UsageLimits/UsagePanelContent.tsx
index e351c7f1a0..e6f50e9ed6 100644
--- a/autogpt_platform/frontend/src/app/(platform)/copilot/components/UsageLimits/UsagePanelContent.tsx
+++ b/autogpt_platform/frontend/src/app/(platform)/copilot/components/UsageLimits/UsagePanelContent.tsx
@@ -5,6 +5,7 @@ import { cn } from "@/lib/utils";
import Link from "next/link";
import { formatCents, formatResetTime } from "../usageHelpers";
import { useResetRateLimit } from "../../hooks/useResetRateLimit";
+import { useWorkspaceStorage } from "./useWorkspaceStorage";
export { formatResetTime };
@@ -70,6 +71,65 @@ function UsageBar({
);
}
+export function formatBytes(bytes: number): string {
+ const KB = 1024;
+ const MB = KB * 1024;
+ const GB = MB * 1024;
+ if (bytes < KB) return `${bytes} B`;
+ if (bytes < MB) {
+ const kb = Math.round(bytes / KB);
+ return kb >= 1024 ? `${(bytes / MB).toFixed(1)} MB` : `${kb} KB`;
+ }
+ if (bytes < GB) {
+ const mb = Math.round(bytes / MB);
+ return mb >= 1024 ? `${(bytes / GB).toFixed(1)} GB` : `${mb} MB`;
+ }
+ return `${(bytes / GB).toFixed(1)} GB`;
+}
+
+function StorageBar({
+ usedBytes,
+ limitBytes,
+ fileCount,
+}: {
+ usedBytes: number;
+ limitBytes: number;
+ fileCount: number;
+}) {
+ if (limitBytes <= 0) return null;
+
+ const rawPercent = (usedBytes / limitBytes) * 100;
+ const percent = Math.min(100, Math.round(rawPercent));
+ const isHigh = percent >= 80;
+ const percentLabel =
+ usedBytes > 0 && percent === 0 ? "<1% used" : `${percent}% used`;
+
+ return (
+ <div className="flex flex-col gap-1">
+ <div className="flex items-baseline justify-between">
+ <span className="text-xs font-medium text-neutral-700">
+ File storage
+ </span>
+ <span className="text-[11px] tabular-nums text-neutral-500">
+ {percentLabel}
+ </span>
+ </div>
+ <div className="text-[10px] text-neutral-400">
+ {formatBytes(usedBytes)} of {formatBytes(limitBytes)} &middot;{" "}
+ {fileCount} {fileCount === 1 ? "file" : "files"}
+ </div>
+ <div className="h-2 w-full overflow-hidden rounded-full bg-neutral-200">
+ <div
+ className={`h-full rounded-full transition-[width] duration-300 ease-out ${
+ isHigh ? "bg-orange-500" : "bg-blue-500"
+ }`}
+ style={{ width: `${Math.max(usedBytes > 0 ? 1 : 0, percent)}%` }}
+ />
+ </div>
+ </div>
+ );
+}
+
function ResetButton({
cost,
onCreditChange,
@@ -94,6 +154,19 @@ function ResetButton({
);
}
+function WorkspaceStorageSection() {
+ const { data: storage } = useWorkspaceStorage();
+ if (!storage || storage.limit_bytes <= 0) return null;
+
+ return (
+ <StorageBar
+ usedBytes={storage.used_bytes}
+ limitBytes={storage.limit_bytes}
+ fileCount={storage.file_count}
+ />
+ );
+}
+
export function UsagePanelContent({
usage,
showHeader = true,
@@ -119,9 +192,12 @@ export function UsagePanelContent({
if (!daily && !weekly) {
return (
- <Text as="span" variant="small" className="text-neutral-500">
- No usage limits configured
- </Text>
+ <div className="flex flex-col gap-3">
+ <Text as="span" variant="small" className="text-neutral-500">
+ No usage limits configured
+ </Text>
+ <WorkspaceStorageSection />
+ </div>
);
}
@@ -163,6 +239,7 @@ export function UsagePanelContent({
size={size}
/>
)}
+ <WorkspaceStorageSection />
{isDailyExhausted &&
!isWeeklyExhausted &&
resetCost > 0 &&
diff --git a/autogpt_platform/frontend/src/app/(platform)/copilot/components/UsageLimits/__tests__/UsagePanelContentRender.test.tsx b/autogpt_platform/frontend/src/app/(platform)/copilot/components/UsageLimits/__tests__/UsagePanelContentRender.test.tsx
index 7d8fd4fe38..355c050abc 100644
--- a/autogpt_platform/frontend/src/app/(platform)/copilot/components/UsageLimits/__tests__/UsagePanelContentRender.test.tsx
+++ b/autogpt_platform/frontend/src/app/(platform)/copilot/components/UsageLimits/__tests__/UsagePanelContentRender.test.tsx
@@ -4,8 +4,8 @@ import {
cleanup,
fireEvent,
} from "@/tests/integrations/test-utils";
-import { afterEach, describe, expect, it, vi } from "vitest";
-import { UsagePanelContent } from "../UsagePanelContent";
+import { afterEach, beforeEach, describe, expect, it, vi } from "vitest";
+import { UsagePanelContent, formatBytes } from "../UsagePanelContent";
import type { CoPilotUsagePublic } from "@/app/api/__generated__/models/coPilotUsagePublic";
const mockResetUsage = vi.fn();
@@ -13,9 +13,20 @@ vi.mock("../../../hooks/useResetRateLimit", () => ({
useResetRateLimit: () => ({ resetUsage: mockResetUsage, isPending: false }),
}));
+const mockStorageData = vi.fn();
+vi.mock("../useWorkspaceStorage", () => ({
+ useWorkspaceStorage: () => mockStorageData(),
+}));
+
afterEach(() => {
cleanup();
mockResetUsage.mockReset();
+ mockStorageData.mockReset();
+});
+
+// Default: no storage data (most existing tests don't need it)
+beforeEach(() => {
+ mockStorageData.mockReturnValue({ data: undefined });
});
function makeUsage(
@@ -47,6 +58,25 @@ function makeUsage(
} as CoPilotUsagePublic;
}
+describe("formatBytes", () => {
+ it.each([
+ [0, "0 B"],
+ [512, "512 B"],
+ [1024, "1 KB"],
+ [250 * 1024, "250 KB"],
+ [1023 * 1024, "1023 KB"],
+ [1000 * 1024, "1000 KB"],
+ [1024 * 1024, "1 MB"],
+ [250 * 1024 * 1024, "250 MB"],
+ [1000 * 1024 * 1024, "1000 MB"],
+ [1024 * 1024 * 1024, "1.0 GB"],
+ [5 * 1024 * 1024 * 1024, "5.0 GB"],
+ [15 * 1024 * 1024 * 1024, "15.0 GB"],
+ ])("formats %d bytes as %s", (input, expected) => {
+ expect(formatBytes(input)).toBe(expected);
+ });
+});
+
describe("UsagePanelContent", () => {
it("renders 'No usage limits configured' when both windows are null", () => {
render(
@@ -57,6 +87,26 @@ describe("UsagePanelContent", () => {
expect(screen.getByText("No usage limits configured")).toBeDefined();
});
+ it("still renders file storage when usage windows are null", () => {
+ mockStorageData.mockReturnValue({
+ data: {
+ used_bytes: 100 * 1024 * 1024,
+ limit_bytes: 250 * 1024 * 1024,
+ used_percent: 40,
+ file_count: 5,
+ },
+ });
+
+ render(
+ <UsagePanelContent
+ usage={makeUsage({ dailyPercent: null, weeklyPercent: null })}
+ />,
+ );
+
+ expect(screen.getByText("No usage limits configured")).toBeDefined();
+ expect(screen.getByText("File storage")).toBeDefined();
+ });
+
it("renders the reset button when daily limit is exhausted", () => {
render(
<UsagePanelContent
@@ -109,4 +159,94 @@ describe("UsagePanelContent", () => {
render(<UsagePanelContent usage={makeUsage({ dailyPercent: 0.3 })} />);
expect(screen.getByText("<1% used")).toBeDefined();
});
+
+ it("renders file storage bar when workspace data is available", () => {
+ mockStorageData.mockReturnValue({
+ data: {
+ used_bytes: 100 * 1024 * 1024,
+ limit_bytes: 250 * 1024 * 1024,
+ used_percent: 40,
+ file_count: 5,
+ },
+ });
+
+ render(<UsagePanelContent usage={makeUsage()} />);
+ expect(screen.getByText("File storage")).toBeDefined();
+ expect(screen.getByText(/100 MB of 250 MB/)).toBeDefined();
+ expect(screen.getByText(/5 files/)).toBeDefined();
+ });
+
+ it("hides file storage bar when no workspace data", () => {
+ mockStorageData.mockReturnValue({ data: undefined });
+
+ render(<UsagePanelContent usage={makeUsage()} />);
+ expect(screen.queryByText("File storage")).toBeNull();
+ });
+
+ it("hides file storage bar when limit is zero", () => {
+ mockStorageData.mockReturnValue({
+ data: {
+ used_bytes: 0,
+ limit_bytes: 0,
+ used_percent: 0,
+ file_count: 0,
+ },
+ });
+
+ render(<UsagePanelContent usage={makeUsage()} />);
+ expect(screen.queryByText("File storage")).toBeNull();
+ });
+
+ it("shows orange bar when storage usage is at or above 80%", () => {
+ mockStorageData.mockReturnValue({
+ data: {
+ used_bytes: 210 * 1024 * 1024,
+ limit_bytes: 250 * 1024 * 1024,
+ used_percent: 84,
+ file_count: 3,
+ },
+ });
+
+ render(<UsagePanelContent usage={makeUsage()} />);
+ expect(screen.getByText("File storage")).toBeDefined();
+ expect(screen.getByText("84% used")).toBeDefined();
+ });
+
+ it("shows singular 'file' for single file", () => {
+ mockStorageData.mockReturnValue({
+ data: {
+ used_bytes: 1024,
+ limit_bytes: 250 * 1024 * 1024,
+ used_percent: 0,
+ file_count: 1,
+ },
+ });
+
+ render(<UsagePanelContent usage={makeUsage()} />);
+ expect(screen.getByText(/1 file$/)).toBeDefined();
+ });
+
+ it("shows storage '<1% used' when usage is tiny", () => {
+ mockStorageData.mockReturnValue({
+ data: {
+ used_bytes: 100,
+ limit_bytes: 250 * 1024 * 1024,
+ used_percent: 0.001,
+ file_count: 1,
+ },
+ });
+
+ render(<UsagePanelContent usage={makeUsage()} />);
+ expect(screen.getByText("File storage")).toBeDefined();
+ });
+
+ it("renders header with tier label", () => {
+ render(<UsagePanelContent usage={makeUsage({ tier: "PRO" })} />);
+ expect(screen.getByText("Pro plan")).toBeDefined();
+ });
+
+ it("hides header when showHeader is false", () => {
+ render(<UsagePanelContent usage={makeUsage()} showHeader={false} />);
+ expect(screen.queryByText("Usage limits")).toBeNull();
+ });
});
diff --git a/autogpt_platform/frontend/src/app/(platform)/copilot/components/UsageLimits/useWorkspaceStorage.ts b/autogpt_platform/frontend/src/app/(platform)/copilot/components/UsageLimits/useWorkspaceStorage.ts
new file mode 100644
index 0000000000..e9cc24018d
--- /dev/null
+++ b/autogpt_platform/frontend/src/app/(platform)/copilot/components/UsageLimits/useWorkspaceStorage.ts
@@ -0,0 +1,12 @@
+import { useGetWorkspaceStorageUsage } from "@/app/api/__generated__/endpoints/workspace/workspace";
+import type { StorageUsageResponse } from "@/app/api/__generated__/models/storageUsageResponse";
+
+export function useWorkspaceStorage() {
+ return useGetWorkspaceStorageUsage({
+ query: {
+ select: (res) => res.data as StorageUsageResponse,
+ staleTime: 30000,
+ refetchInterval: 60000,
+ },
+ });
+}
diff --git a/autogpt_platform/frontend/src/app/(platform)/profile/(user)/credits/page.tsx b/autogpt_platform/frontend/src/app/(platform)/profile/(user)/credits/page.tsx
index f6f9398721..28e7e49d0f 100644
--- a/autogpt_platform/frontend/src/app/(platform)/profile/(user)/credits/page.tsx
+++ b/autogpt_platform/frontend/src/app/(platform)/profile/(user)/credits/page.tsx
@@ -40,7 +40,7 @@ function CoPilotUsageSection() {
return (
<div className="my-6 space-y-4">
- <h3 className="text-lg font-medium">AutoPilot Usage Limits</h3>
+ <h3 className="text-lg font-medium">AutoPilot Usage & Storage</h3>
<div className="rounded-lg border border-neutral-200 p-4">
<UsagePanelContent usage={usage} showBillingLink={false} />
</div>
diff --git a/autogpt_platform/frontend/src/lib/direct-upload.ts b/autogpt_platform/frontend/src/lib/direct-upload.ts
index 22fd79f4a4..c6050fc84a 100644
--- a/autogpt_platform/frontend/src/lib/direct-upload.ts
+++ b/autogpt_platform/frontend/src/lib/direct-upload.ts
@@ -40,8 +40,18 @@ export async function uploadFileDirect(
});
if (!res.ok) {
- const detail = await res.text().catch(() => res.statusText);
- throw new Error(`Upload failed (${res.status}): ${detail}`);
+ let message: string;
+ try {
+ const body = await res.json();
+ // Backend returns { detail: "..." } or { detail: { message: "..." } }
+ message =
+ typeof body.detail === "string"
+ ? body.detail
+ : (body.detail?.message ?? res.statusText);
+ } catch {
+ message = res.statusText;
+ }
+ throw new Error(message);
}
return res.json();
diff --git a/codecov.yml b/codecov.yml
index c59e08e110..a0973b5717 100644
--- a/codecov.yml
+++ b/codecov.yml
@@ -21,7 +21,7 @@ coverage:
flags:
- platform-backend
platform-frontend:
- target: 80%
+ target: 70%
flags:
- platform-frontend
autogpt-libs:
@@ -80,7 +80,7 @@ component_management:
target: auto
informational: true
- type: patch
- target: 80%
+ target: 70%
informational: true
- component_id: autogpt-libs
name: "AutoGPT Libs"