@@ -238,3 +238,45 @@ def test_row_sum_varargs(self, fixture_worker: str) -> None:
 
         assert len(results) == 1
         assert results[0].column("row_sum").to_pylist() == [3.0, 5.0]
+
+
+class TestHasFinalizeSkip:
+    """`has_finalize=False` skips the FINALIZE `init()` entirely for a no-finalize function.
+
+    Real interop bug found live against a non-Python worker SDK: the client
+    unconditionally sent a FINALIZE-phase init() for every table-in-out call,
+    which the Python fixture worker happens to no-op gracefully but a
+    TypeScript-SDK worker rejects outright ("a blended row-transform function
+    has no FINALIZE phase"). `has_finalize=False` avoids sending that init()
+    at all rather than depending on every SDK tolerating an unexpected one.
+    Output must be identical either way for a function that has no finalize
+    stage (there is nothing to skip yielding) -- this is the equivalence this
+    suite can prove locally; the cross-SDK rejection itself is TypeScript-only.
+    """
+
+    def test_output_identical_with_and_without_has_finalize(self, client_transport: Any) -> None:
+        """Same output whether the FINALIZE init() is sent or skipped, both transports."""
+        input_schema = make_schema([pa.field("n", pa.int64())])
+        batch = pa.RecordBatch.from_pydict({"n": [0, 1, 3, 2]}, schema=input_schema)
+
+        with client_transport() as client:
+            with_finalize = list(
+                client.table_in_out_function(
+                    function_name="blended_explode",
+                    schema_name="main",
+                    input=iter([batch]),
+                )
+            )
+        with client_transport() as client:
+            without_finalize = list(
+                client.table_in_out_function(
+                    function_name="blended_explode",
+                    schema_name="main",
+                    input=iter([batch]),
+                    has_finalize=False,
+                )
+            )
+
+        assert len(with_finalize) == 1
+        assert len(without_finalize) == 1
+        assert with_finalize[0].column("i").to_pylist() == without_finalize[0].column("i").to_pylist()
@@ -1915,6 +1915,7 @@ def table_in_out_function(
         settings: dict[str, Any] | None = None,
         transaction_opaque_data: bytes | None = None,
         parent_row_callback: Callable[[list[int]], None] | None = None,
+        has_finalize: bool = True,
     ) -> Generator[pa.RecordBatch]:
         """Invoke a table-in-out function on the worker and stream results.
 
@@ -1956,6 +1957,20 @@ def table_in_out_function(
                 `FunctionInfo.input_from_args`); leave unset for ordinary
                 table-in-out functions, which have no provenance concept and
                 may legitimately change row count.
+            has_finalize: Whether this function declares a FINALIZE stage
+                (`FunctionInfo.has_finalize`). Defaults to `True` — every
+                caller before this parameter existed got a FINALIZE-phase
+                `init()` unconditionally, so this preserves that exactly.
+                Pass `False` for a function known to have no finalize (every
+                blended `RowTransformFunction` — `has_finalize` is always
+                false for those, enforced at `resolve_metadata()`) to skip
+                the FINALIZE `init()` entirely, not just send one expecting
+                an empty reply. Confirmed load-bearing, not cosmetic: some
+                worker SDKs (e.g. the TypeScript one) actively reject an
+                unexpected FINALIZE `init()` for a function that never
+                advertised `has_finalize`, rather than silently no-op'ing
+                it — the C++ DuckDB extension avoids this the same way, by
+                conditionally registering `in_out_function_final` at all.
 
         Yields:
             Output `RecordBatch`es from the function. In single-worker mode, output
@@ -2019,7 +2034,14 @@ def table_in_out_function(
                 # Close secondary workers
                 self._close_secondary_workers()
 
-                # Finalize on primary worker
+                # Finalize on primary worker — skipped entirely (not just
+                # sent expecting an empty reply) when the function has no
+                # finalize stage. See has_finalize's docstring: some worker
+                # SDKs reject an unadvertised FINALIZE init() outright.
+                if not has_finalize:
+                    _logger.debug("skipping_finalize_no_finalize_stage")
+                    return
+
                 _logger.debug("finalizing_primary_worker")
                 yield from self._finalize_primary_worker(
                     bind_request,