2noise/ChatTTS · error · NotImplementedError

max_concurrent_workers is not supported yet.

Error message

max_concurrent_workers is not supported yet.

What it means

_run_workers broadcasts a method call to all engine workers (Ray actors and the local driver worker). A max_concurrent_workers parameter exists in the signature for capping concurrency, but it is unimplemented: any truthy value raises NotImplementedError. It is dead API surface kept from upstream vLLM.

Source

Thrown at ChatTTS/model/velocity/llm_engine.py:811

        if (not sampling_params.ignore_eos) and seq.get_last_token_id()[
            0
        ] == sampling_params.eos_token:
            seq.status = SequenceStatus.FINISHED_STOPPED
            return

    def _run_workers(
        self,
        method: str,
        *args,
        driver_args: Optional[List[Any]] = None,
        driver_kwargs: Optional[Dict[str, Any]] = None,
        max_concurrent_workers: Optional[int] = None,
        **kwargs,
    ) -> Any:
        """Runs the given method on all workers."""

        if max_concurrent_workers:
            raise NotImplementedError("max_concurrent_workers is not supported yet.")

        # Start the ray workers first.
        ray_worker_outputs = [
            worker.execute_method.remote(method, *args, **kwargs)
            for worker in self.workers
        ]

        if driver_args is None:
            driver_args = args
        if driver_kwargs is None:
            driver_kwargs = kwargs

        # Start the driver worker after all the ray workers.
        driver_worker_output = getattr(self.driver_worker, method)(
            *driver_args, **driver_kwargs
        )

        # Get the results of the ray workers.

View on GitHub (pinned to 77b89ee281)

Solutions

1. Remove the max_concurrent_workers argument - leave it None/default everywhere.
2. If you need the behavior from newer vLLM, port the vendored engine to that version; this fork simply lacks the feature.
3. If porting, implement concurrency capping around the ray.get / execute_method loop and drop the raise.

Example fix

# before
engine._run_workers('profile_num_available_blocks', max_concurrent_workers=4)

# after
engine._run_workers('profile_num_available_blocks')

def run_workers(engine, method, *args, **kwargs):
    kwargs.pop('max_concurrent_workers', None)  # unsupported in this fork
    return engine._run_workers(method, *args, **kwargs)

try:
    engine._run_workers(method, *args, max_concurrent_workers=n)
except NotImplementedError:
    engine._run_workers(method, *args)

When it happens

Trigger: Any internal call path (_init_workers, _init_workers_ray, _init_cache, step) or external code invoking _run_workers with max_concurrent_workers set to a non-zero positive integer.

Common situations: Code copied from a newer vLLM version that uses max_concurrent_workers for CPU offload/parallel init; attempting to speed up worker startup by capping concurrency.

Related errors

• {model_config.dtype} is not supported for quantization metho

AI-assisted analysis of 2noise/ChatTTS@77b89ee281 (2026-08-26). Data as JSON: /api/errors/4dc9bc9ca932a3ec. Report an issue: GitHub.