Open-source platform for 3D AI agents. Turn text or a photo into a rigged, animated GLB avatar, give it an LLM brain, memory and a wallet, and embed it anywhere with one web component. Remote MCP server, x402 payments, Three.js, browser-native.
JavaScript 3d-generationai-agentsanimationavatardigital-humangenerative-aiglbgltfimage-to-3dllmmcpmcp-servermodel-context-protocolsolanatext-to-3dthreejsweb-componentswebglwebxrx402
fix(model-triposg): catch the AttributeError prepare_image raises instead of returning it
nirholascebd04ad0277
diff --git a/workers/model-triposg/main.py b/workers/model-triposg/main.pyindex 4f5e9f52f..5527a739c 100644--- a/workers/model-triposg/main.py+++ b/workers/model-triposg/main.py@@ -299,15 +299,21 @@ def _prepare_photo(src: str) -> Image.Image:with tempfile.NamedTemporaryFile(suffix=".png", delete=False) as tmp:Image.open(io.BytesIO(data)).convert("RGBA").save(tmp, format="PNG")tmp_path = tmp.name+ # Upstream's load_image reports an unusable input by RETURNING a string+ # ("invalid image: pure black image", ...) which prepare_image then calls+ # .permute on itself, so the AttributeError is raised INSIDE prepare_image+ # before it ever returns: an isinstance check on `prepared` below can never+ # see the string, it has to be caught here. (11 of these surfaced as an+ # opaque internal error in the three days to 2026-10-09, then 2 more after+ # the isinstance-only guard below shipped and didn't catch it.)try:prepared = prepare_image(tmp_path, bg_color=np.array([1.0, 1.0, 1.0]), rmbg_net=_rmbg_net)+ except AttributeError:+ raise InputImageError(+ "image has no visible subject (blank, black, or fully transparent)"+ ) from Nonefinally:os.unlink(tmp_path)- # Upstream's load_image reports an unusable input by RETURNING a string- # ("invalid image: pure black image", ...) which prepare_image then calls- # .permute on, so a blank or fully transparent upload used to surface as an- # AttributeError and an opaque internal error (11 of them in the three days- # to 2026-10-09). Name the input as the problem instead.if not isinstance(prepared, Image.Image):raise InputImageError("image has no visible subject (blank, black, or fully transparent)"diff --git a/workers/model-triposg/test_prepare_photo.py b/workers/model-triposg/test_prepare_photo.pynew file mode 100644index 000000000..3e79feffd--- /dev/null+++ b/workers/model-triposg/test_prepare_photo.py@@ -0,0 +1,253 @@+"""Unit test for _prepare_photo's handling of upstream's unusable-image bug.++Upstream's prepare_image() (VAST-AI-Research/TripoSG's image_process.py) reports+a blank/black/fully-transparent input by having its own load_image() RETURN a+string, then immediately calling `.permute()` on that string -- which raises+AttributeError INSIDE prepare_image, before it ever returns. main.py's+_prepare_photo used to only guard against prepare_image returning a string+(`if not isinstance(prepared, Image.Image)`), which never runs because the+AttributeError escapes the call before that line is reached. Production saw 11+of these surface as opaque "AttributeError: 'str' object has no attribute+'permute'" task failures in three days, and two more on 2026-10-11 (06:06 and+20:14 UTC) after the first attempted fix landed.++No torch, no CUDA, no TripoSG source tree, no GCS: every heavy import main.py+makes at module scope (torch, trimesh, fastapi, google.cloud.storage, PIL,+pydantic) is stubbed in sys.modules before main is imported, so this runs+anywhere:++ python3 workers/model-triposg/test_prepare_photo.py++(also collectable by pytest if it is installed).+"""++from __future__ import annotations++import base64+import io+import os+import sys+import types+++def _install_stub_modules() -> None:+ """Install minimal fakes for every heavy module main.py imports at top+ level, just enough for `import main` to succeed without touching any real+ ML/GCP dependency."""++ torch_stub = types.ModuleType("torch")+ torch_stub.float16 = "float16"++ class _Generator:+ def __init__(self, device=None):+ self.device = device++ def manual_seed(self, _seed):+ return self++ torch_stub.Generator = _Generator++ class _NoGrad:+ def __enter__(self):+ return self++ def __exit__(self, *exc):+ return False++ torch_stub.no_grad = _NoGrad++ class _Cuda:+ @staticmethod+ def is_available():+ return False++ @staticmethod+ def get_device_name(_idx):+ return None++ torch_stub.cuda = _Cuda+ sys.modules["torch"] = torch_stub++ trimesh_stub = types.ModuleType("trimesh")++ class _Trimesh:+ pass++ trimesh_stub.Trimesh = _Trimesh+ sys.modules["trimesh"] = trimesh_stub++ fastapi_stub = types.ModuleType("fastapi")++ class _FastAPI:+ def __init__(self, *_args, **_kwargs):+ pass++ def post(self, *_args, **_kwargs):+ return lambda fn: fn++ def get(self, *_args, **_kwargs):+ return lambda fn: fn++ class _HTTPException(Exception):+ def __init__(self, status_code=500, detail=None):+ super().__init__(detail)+ self.status_code = status_code+ self.detail = detail++ def _header(default=None, **_kwargs):+ return default++ class _BackgroundTasks:+ def add_task(self, *_args, **_kwargs):+ pass++ fastapi_stub.FastAPI = _FastAPI+ fastapi_stub.HTTPException = _HTTPException+ fastapi_stub.Header = _header+ fastapi_stub.BackgroundTasks = _BackgroundTasks+ sys.modules["fastapi"] = fastapi_stub++ google_stub = types.ModuleType("google")+ google_api_core_stub = types.ModuleType("google.api_core")+ google_api_core_exceptions_stub = types.ModuleType("google.api_core.exceptions")++ class _NotFound(Exception):+ pass++ google_api_core_exceptions_stub.NotFound = _NotFound+ google_cloud_stub = types.ModuleType("google.cloud")+ google_cloud_storage_stub = types.ModuleType("google.cloud.storage")++ class _Blob:+ def __init__(self, name):+ self.name = name++ class _Bucket:+ def blob(self, name):+ return _Blob(name)++ class _Client:+ def bucket(self, _name):+ return _Bucket()++ google_cloud_storage_stub.Client = _Client+ google_cloud_storage_stub.Bucket = _Bucket+ sys.modules["google"] = google_stub+ sys.modules["google.api_core"] = google_api_core_stub+ sys.modules["google.api_core.exceptions"] = google_api_core_exceptions_stub+ sys.modules["google.cloud"] = google_cloud_stub+ sys.modules["google.cloud.storage"] = google_cloud_storage_stub++ pil_stub = types.ModuleType("PIL")+ pil_image_stub = types.ModuleType("PIL.Image")++ class _Image:+ def __init__(self, size=(1, 1)):+ self.size = size++ def convert(self, _mode):+ return self++ def save(self, fp, format=None): # noqa: A002, matches PIL's signature+ fp.write(b"stub-png-bytes")++ def alpha_composite(self, _other):+ pass++ def _open(_fp):+ return _Image()++ def _new(_mode, size, _color=None):+ return _Image(size=size)++ pil_image_stub.Image = _Image+ pil_image_stub.open = _open+ pil_image_stub.new = _new+ pil_stub.Image = pil_image_stub+ sys.modules["PIL"] = pil_stub+ sys.modules["PIL.Image"] = pil_image_stub++ pydantic_stub = types.ModuleType("pydantic")++ class _BaseModel:+ pass++ def _field(default=..., **_kwargs):+ return default++ pydantic_stub.BaseModel = _BaseModel+ pydantic_stub.Field = _field+ sys.modules["pydantic"] = pydantic_stub+++_install_stub_modules()++os.environ.setdefault("API_KEY", "test-key")+os.environ.setdefault("GCS_BUCKET", "test-bucket")++sys.path.insert(0, os.path.dirname(os.path.abspath(__file__)))++import main # noqa: E402, imported only after the stubs above are in place+++def _data_uri() -> str:+ return "data:image/png;base64," + base64.b64encode(b"irrelevant-bytes").decode()+++def _with_stub_prepare_image(prepare_image_fn):+ """Install a fake `image_process.prepare_image` for the duration of the+ call, then restore whatever (if anything) was there before."""+ image_process_stub = types.ModuleType("image_process")+ image_process_stub.prepare_image = prepare_image_fn+ previous = sys.modules.get("image_process")+ sys.modules["image_process"] = image_process_stub+ try:+ return main._prepare_photo(_data_uri())+ finally:+ if previous is None:+ del sys.modules["image_process"]+ else:+ sys.modules["image_process"] = previous+++def test_blank_image_raises_InputImageError_not_AttributeError():+ """Upstream's prepare_image raises AttributeError (via its own `.permute()`+ call on a string) for a blank/black/transparent input. _prepare_photo must+ translate that into InputImageError, the designed per-input failure the+ rest of main.py already knows how to report (see _run_inference's+ `except InputImageError` branch), not let it escape as an opaque crash."""++ def _prepare_image(_path, bg_color=None, rmbg_net=None):+ raise AttributeError("'str' object has no attribute 'permute'")++ try:+ _with_stub_prepare_image(_prepare_image)+ raise AssertionError("expected InputImageError")+ except main.InputImageError as exc:+ assert "no visible subject" in str(exc), exc+ except AttributeError as exc: # pragma: no cover, the bug this test guards+ raise AssertionError(+ f"AttributeError escaped _prepare_photo instead of becoming "+ f"InputImageError: {exc}"+ ) from exc+++def test_usable_image_passes_through():+ """The success path still returns prepare_image's PIL.Image untouched."""++ sentinel = main.Image.Image()++ def _prepare_image(_path, bg_color=None, rmbg_net=None):+ return sentinel++ result = _with_stub_prepare_image(_prepare_image)+ assert result is sentinel+++if __name__ == "__main__":+ tests = [v for k, v in sorted(globals().items()) if k.startswith("test_")]+ for t in tests:+ t()+ print(f"ok {t.__name__}")+ print(f"{len(tests)} passed")+ sys.exit(0)