fix: round-trip serialization of Ellipsis in variadic tuple and Callable types

[winklemad]

serialize_type rendered the ... in types like tuple[int, ...] and Callable[..., X] as the literal string "Ellipsis" (it fell through to str(Ellipsis)), which deserialize_type then rejected — the "Ellipsis" token hits the builtin-type gate and is correctly refused since Ellipsis isn't a type.

The result is a serialization round-trip break: any component given a variadic-tuple or Callable[..., X] type — e.g. OutputAdapter(output_type=tuple[int, ...]), ConditionalRouter/MetadataRouter route types, ListJoiner/BranchJoiner, LLMEvaluator, an Agent State schema — produces a pipeline that Pipeline.dumps() writes but Pipeline.loads() hard-rejects.

Fix: serialize_type emits "..." (the literal Python itself uses) for Ellipsis, and deserialize_type resolves the non-type singletons (None, NoneType, ..., plus the legacy "Ellipsis") up front — before the module-path branch, since the dots in "..." would otherwise be read as a module path. Covers both variadic tuples and Callable[..., X]; legacy "Ellipsis" payloads still load. Added round-trip regression tests for variadic tuples and Callable-with-Ellipsis.

[vercel]

@winklemad is attempting to deploy a commit to the deepset Team on Vercel.

A member of the Team first needs to authorize it.

[CLAassistant]

All committers have signed the CLA.

[github-actions]

Coverage report

Click to see where and how coverage changed

File	Statements	Missing	Coverage	Coverage (new stmts)	Lines missing
haystack/core/pipeline
pipeline.py
haystack/utils
type_serialization.py					219
Project Total

This report was generated by python-coverage-comment-action

[anakin87]

Thank you, the fix looks good!

I only found two minor opportunities to improve this PR...

[anakin87]

nitpick: I'd use a _SPECIAL_LITERALS constant defined on the module

[anakin87]

Suggested change

	def test_output_type_serialization_ellipsis():
	# The `...` (Ellipsis) singleton is serialized to the literal "..." Python itself uses when rendering
	# variadic tuples and Callable, not to str(Ellipsis) == "Ellipsis" (which is not a type).
	assert serialize_type(tuple[int, ...]) == "tuple[int, ...]"
	assert serialize_type(Tuple[int, ...]) == "typing.Tuple[int, ...]"
	assert serialize_type(Callable[..., int]) == "typing.Callable[..., int]"
	def test_output_type_round_trip_variadic_tuple_and_callable_ellipsis():
	# Regression: `...` used to be serialized as "Ellipsis", which deserialize_type then rejected as a
	# non-type builtin, so a type Haystack serialized itself could not be read back.
	for type_ in [
	tuple[int, ...],
	tuple[str, ...],
	tuple[dict[str, int], ...],
	Tuple[int, ...],
	Callable[..., int],
	Callable[..., str],
	]:
	assert deserialize_type(serialize_type(type_)) == type_

Let's add

pytest.param("typing.Callable[..., int]", Callable[..., int]),
pytest.param("typing.Callable[..., str]", Callable[..., str]),

to TYPING_AND_TYPE_TESTS, so that the above-mentioned tests become fully redundant and we can remove them.

[winklemad]

Done, thanks for the review!

• Extracted the lookup into a module-level _SPECIAL_LITERALS constant and reference it from deserialize_type.
• Added pytest.param("typing.Callable[..., int]", Callable[..., int]) and pytest.param("typing.Callable[..., str]", Callable[..., str]) to TYPING_AND_TYPE_TESTS. The variadic-tuple cases were already in that list, so with Callable added the two standalone tests were fully redundant — removed both. I kept test_output_type_deserialization_legacy_ellipsis_literal, which covers reading back the legacy "Ellipsis" literal (not exercised by the round-trip params).

[anakin87]

Thank you!