{"record":{"id":"a2731be3807ef02d","repo":"huggingface/smolagents","slug":"cannot-safely-serialize-object-of-type-type-obj","errorCode":null,"errorMessage":"Cannot safely serialize object of type {type(obj).__name__}","messagePattern":"Cannot safely serialize object of type (.+?)","errorType":"exception","errorClass":"SerializationError","httpStatus":null,"severity":"error","filePath":"src/smolagents/remote_executors.py","lineNumber":256,"sourceCode":"                        return {\"__type__\": \"ndarray\", \"data\": obj.tolist(), \"dtype\": str(obj.dtype)}\n                    elif isinstance(obj, (np.integer, np.floating)):\n                        return obj.item()\n                except ImportError:\n                    pass\n\n                # Try dataclass\n                import dataclasses\n\n                if dataclasses.is_dataclass(obj) and not isinstance(obj, type):\n                    return {\n                        \"__type__\": \"dataclass\",\n                        \"class_name\": type(obj).__name__,\n                        \"module\": type(obj).__module__,\n                        \"data\": {f.name: _to_json_safe(getattr(obj, f.name)) for f in dataclasses.fields(obj)},\n                    }\n\n                # Cannot safely serialize - raise error for safe mode\n                raise SerializationError(f\"Cannot safely serialize object of type {type(obj).__name__}\")\n\n            def _serialize_with_fallback(obj):\n                \"\"\"Serialize with safe method, fallback to pickle if allowed.\"\"\"\n                import pickle\n\n                if not ALLOW_PICKLE:\n                    # Safe ONLY mode - NO pickle fallback, raise error if can't serialize\n                    json_safe = _to_json_safe(obj)  # Will raise SerializationError if fails\n                    return \"safe:\" + json.dumps(json_safe)\n                else:\n                    # Try safe first, fallback to pickle if allowed\n                    try:\n                        json_safe = _to_json_safe(obj)\n                        return \"safe:\" + json.dumps(json_safe)\n                    except SerializationError:\n                        # Fallback to pickle\n                        try:\n                            return \"pickle:\" + base64.b64encode(pickle.dumps(obj)).decode()","sourceCodeStart":238,"sourceCodeEnd":274,"githubUrl":"https://github.com/huggingface/smolagents/blob/30bb1161095dbae2271e6bc3cc4c219cc3897a57/src/smolagents/remote_executors.py#L238-L274","documentation":"SerializationError raised in safe (no-pickle) mode when _to_json_safe encounters an object it cannot represent as JSON: not a dataclass, and not any of the whitelisted primitive/container types. Safe mode fails closed rather than silently dropping data.","triggerScenarios":"Returning an object as a final answer from remote-executed code (or passing one in additional_imports state) that is an arbitrary class instance, lambda, file handle, numpy array, etc., while allow_pickle=False.","commonSituations":"Final answer is a custom class, pandas/numpy object, or ORM model; migrating from pickle-based serialization to the default safe serializer; Docker/E2B executors returning rich objects.","solutions":["Return JSON-friendly types (dict, list, str, int, float, bool, None, enums, dataclasses) from executed code / final answers","Add a dataclass or as_dict() conversion for the object before returning it","Set allow_pickle=True on the executor if you trust the sandbox (e.g. DockerExecutor(..., allow_pickle=True))"],"exampleFix":"# before\nclass Point:\n    def __init__(self, x, y):\n        self.x, self.y = x, y\nfinal_answer = Point(1, 2)\n\n# after\nfrom dataclasses import dataclass\n\n@dataclass\nclass Point:\n    x: int\n    y: int\nfinal_answer = Point(1, 2)","handlingStrategy":"validation","validationCode":"import dataclasses, enum\nSAFE_TYPES = (str, int, float, bool, type(None), list, dict, tuple, enum.Enum)\n\ndef is_json_safe(obj) -> bool:\n    if isinstance(obj, SAFE_TYPES):\n        return True\n    return dataclasses.is_dataclass(obj) and not isinstance(obj, type)","typeGuard":"def is_json_safe(obj) -> bool:\n    import dataclasses, enum\n    if isinstance(obj, (str, int, float, bool, type(None), enum.Enum)):\n        return True\n    if isinstance(obj, (list, tuple, set)):\n        return all(is_json_safe(x) for x in obj)\n    if isinstance(obj, dict):\n        return all(isinstance(k, str) and is_json_safe(v) for k, v in obj.items())\n    return dataclasses.is_dataclass(type(obj))","tryCatchPattern":"from smolagents.remote_executors import SerializationError\n\ntry:\n    output = executor.run_code_raise_errors(code)\nexcept SerializationError as e:\n    output = executor.run_code_raise_errors(\"final_answer(str(result))\")","preventionTips":["Return primitives/dataclasses from executed code","Convert rich objects with to_dict() before returning","Only enable allow_pickle on trusted sandboxes"],"tags":["serialization","json","pickle","safe-mode","final-answer"],"backgroundTag":"object-not-json-serializable","analyzedSha":"30bb1161095dbae2271e6bc3cc4c219cc3897a57","analyzedAt":"2026-08-28T18:52:54.169Z","schemaVersion":2},"datasetVersion":"2026-08-28T21:17:43.275Z"}