Support dict unpacking in dict literals in the local Python executor

src/smolagents/local_python_executor.py

@@ -1493,10 +1493,18 @@ def evaluate_ast(
     elif isinstance(expression, ast.FunctionDef):
         return evaluate_function_def(expression, *common_params)
     elif isinstance(expression, ast.Dict):
-        # Dict -> evaluate all keys and values
-        keys = (evaluate_ast(k, *common_params) for k in expression.keys)
-        values = (evaluate_ast(v, *common_params) for v in expression.values)
-        return dict(zip(keys, values))
+        # Dict -> evaluate all keys and values; a None key marks a `**mapping` entry to merge
+        result = {}
+        for key_node, value_node in zip(expression.keys, expression.values):
+            if key_node is None:
+                value = evaluate_ast(value_node, *common_params)
+                if not isinstance(value, Mapping):
+                    raise InterpreterError(f"'{type(value).__name__}' object is not a mapping")
+                result.update(value)
+            else:
+                key = evaluate_ast(key_node, *common_params)
+                result[key] = evaluate_ast(value_node, *common_params)
+        return result
     elif isinstance(expression, ast.Expr):
         # Expression -> evaluate the content
         return evaluate_ast(expression.value, *common_params)

tests/test_local_python_executor.py

@@ -263,6 +263,25 @@ def test_evaluate_dict(self):
             state, {"x": 3, "test_dict": {"x": 3, "y": 5}, "_operations_count": {"counter": 7}}
         )
 
+    @pytest.mark.parametrize(
+        "code, expected",
+        [
+            ("{**{'a': 1}, 'b': 2}", {"a": 1, "b": 2}),
+            ("{**{'a': 1}, **{'b': 2}}", {"a": 1, "b": 2}),
+            ("{**{'a': 1}, 'a': 2}", {"a": 2}),
+            ("{'a': 0, **{'a': 1}}", {"a": 1}),
+            ("base = {'x': 1}\n{**base, 'y': 2}", {"x": 1, "y": 2}),
+            ("{**{}}", {}),
+        ],
+    )
+    def test_evaluate_dict_unpacking(self, code, expected):
+        result, _ = evaluate_python_code(code, {}, state={})
+        assert result == expected
+
+    def test_evaluate_dict_unpacking_non_mapping_raises(self):
+        with pytest.raises(InterpreterError, match="'list' object is not a mapping"):
+            evaluate_python_code("{**[1, 2]}", {}, state={})
+
     def test_evaluate_expression(self):
         code = "x = 3\ny = 5"
         state = {}