@@ -1286,6 +1286,7 @@ async def call_task(
         wait: timedelta | None = None,
         token: str | None = None,
         run_name: str | None = None,
+        abort_with_parent: bool = False,
     ) -> Run:
         """Start an Actor task on the Apify Platform and wait for it to finish before returning.
 
@@ -1317,10 +1318,16 @@ async def call_task(
                 resurrected, and a new run is started only when nothing is recorded under the name, or the recorded
                 run `FAILED` or no longer exists. The name is bound to `task_id` exactly as passed, so reusing it with
                 any other value, or for an Actor, raises a `ValueError`.
+            abort_with_parent: If true, the child run is gracefully aborted when this Actor run is gracefully
+                aborted. It requires `run_name`, and the value is recorded under it, replacing the one from an earlier
+                call. A hard abort, a timeout or a crash of this Actor run leaves the child running.
 
         Returns:
             Info about the started Actor run.
         """
+        if abort_with_parent and run_name is None:
+            raise ValueError('`abort_with_parent` requires `run_name`, since only named child runs are tracked.')
+
         client = self.new_client(token=token) if token else self.apify_client
 
         if timeout == 'inherit':
@@ -1363,7 +1370,7 @@ async def call_task(
                 restart_on_error=restart_on_error,
                 memory_mbytes=memory_mbytes,
                 run_timeout=task_call_timeout,
-                abort_with_parent=False,
+                abort_with_parent=abort_with_parent,
             )
             run = await self._wait_for_child_run(
                 client.run(started_run.id), started_run, wait=wait, logger=None, from_start=False
 
@@ -111,7 +111,7 @@ async def main() -> None:
                 return
 
             actor_id = Actor.configuration.actor_id or ''
-            await Actor.start(actor_id=actor_id, run_input={'is_child': True}, name='child', abort_with_parent=True)
+            await Actor.start(actor_id=actor_id, run_input={'is_child': True}, run_name='child', abort_with_parent=True)
             await asyncio.sleep(300)
 
     actor = await make_actor(label='child-run-abort-with-parent', main_func=main)
 
@@ -521,21 +521,24 @@ async def test_child_runs_includes_run_started_in_this_attempt(
     [
         pytest.param('start', id='start'),
         pytest.param('call', id='call'),
+        pytest.param('call_task', id='call task'),
     ],
 )
-async def test_abort_with_parent_requires_name(
+async def test_abort_with_parent_requires_run_name(
     apify_client_async_patcher: ApifyClientAsyncPatcher, method: str
 ) -> None:
-    """`abort_with_parent` without a `name` raises before any run is started."""
-    apify_client_async_patcher.patch('actor', 'start', return_value=make_run('new-run', 'READY'))
-    apify_client_async_patcher.patch('actor', 'call', return_value=make_run('new-run', 'SUCCEEDED'))
+    """`abort_with_parent` without a `run_name` raises before any run is started."""
+    for resource in ('actor', 'task'):
+        apify_client_async_patcher.patch(resource, 'start', return_value=make_run('new-run', 'READY'))
+        apify_client_async_patcher.patch(resource, 'call', return_value=make_run('new-run', 'SUCCEEDED'))
 
     async with Actor:
         with pytest.raises(ValueError, match='requires `run_name`'):
-            await getattr(Actor, method)('some-actor', abort_with_parent=True)
+            await getattr(Actor, method)('some-id', abort_with_parent=True)
 
-    assert apify_client_async_patcher.calls['actor']['start'] == []
-    assert apify_client_async_patcher.calls['actor']['call'] == []
+    for resource in ('actor', 'task'):
+        assert apify_client_async_patcher.calls[resource]['start'] == []
+        assert apify_client_async_patcher.calls[resource]['call'] == []
 
 
 async def test_named_start_records_abort_with_parent(apify_client_async_patcher: ApifyClientAsyncPatcher) -> None:
@@ -550,6 +553,21 @@ async def test_named_start_records_abort_with_parent(apify_client_async_patcher:
     assert stored['scrape-eu']['abortWithParent'] is True
 
 
+async def test_named_call_task_records_abort_with_parent(
+    apify_client_async_patcher: ApifyClientAsyncPatcher,
+) -> None:
+    """A named task call with `abort_with_parent` records the flag with the run."""
+    apify_client_async_patcher.patch('task', 'start', return_value=make_run('new-run', 'READY'))
+    apify_client_async_patcher.patch('run', 'wait_for_finish', return_value=make_run('new-run', 'SUCCEEDED'))
+
+    async with Actor:
+        await Actor.call_task('some-task', run_name='scrape-eu', abort_with_parent=True)
+        kvs = await Actor.open_key_value_store()
+        stored = await kvs.get_value(CHILD_RUNS_KEY)
+
+    assert stored['scrape-eu']['abortWithParent'] is True
+
+
 async def test_reattach_replaces_recorded_abort_with_parent(
     apify_client_async_patcher: ApifyClientAsyncPatcher,
 ) -> None:
@@ -734,7 +752,7 @@ async def test_exit_removes_the_aborting_listener(
 
     async with apify_event_manager:
         async with Actor:
-            await Actor.start('some-actor', name='scrape-eu', abort_with_parent=True)
+            await Actor.start('some-actor', run_name='scrape-eu', abort_with_parent=True)
         apify_event_manager.emit(event=Event.ABORTING, event_data=EventAbortingData())
         await apify_event_manager.wait_for_all_listeners_to_complete()
 
@@ -750,7 +768,7 @@ async def test_removing_all_aborting_listeners_keeps_aborting_child_runs(
     apify_client_async_patcher.patch('run', 'abort', return_value=None)
 
     async with Actor:
-        await Actor.start('some-actor', name='scrape-eu', abort_with_parent=True)
+        await Actor.start('some-actor', run_name='scrape-eu', abort_with_parent=True)
         apify_event_manager.off(event=Event.ABORTING)
         apify_event_manager.emit(event=Event.ABORTING, event_data=EventAbortingData())
         await apify_event_manager.wait_for_all_listeners_to_complete()