microsoft/VibeVoice · error · NotImplementedError

VibeVoiceStreamingProcessor.call is not implemented. Use

Error message

VibeVoiceStreamingProcessor.__call__ is not implemented. Use process_input_with_cached_prompt for streaming inputs.

What it means

VibeVoiceStreamingProcessor deliberately overrides ProcessorMixin.__call__ to raise NotImplementedError. Streaming inference maintains a cached prompt/kv state between chunks, so the stateless one-shot __call__ contract cannot be honored correctly; callers are redirected to process_input_with_cached_prompt. This is an API-design decision, not a bug.

Source

Thrown at vibevoice/processor/vibevoice_streaming_processor.py:165

                "normalize_audio": getattr(self.audio_processor, 'normalize_audio', True),
                "target_dB_FS": getattr(self.audio_processor, 'target_dB_FS', -25),
                "eps": getattr(self.audio_processor, 'eps', 1e-6),
            }
        }
        
        config_path = os.path.join(save_directory, "preprocessor_config.json")
        with open(config_path, 'w') as f:
            json.dump(processor_config, f, indent=2)
        
        logger.info(f"Processor configuration saved in {config_path}")
    
    def __call__(self) -> BatchEncoding:
        """
        Note:
            This method is intentionally not implemented in the streaming processor.
            Use `process_input_with_cached_prompt` for streaming use cases.
        """
        raise NotImplementedError(
            "VibeVoiceStreamingProcessor.__call__ is not implemented. "
            "Use process_input_with_cached_prompt for streaming inputs."
        )

    def process_input_with_cached_prompt(
        self,
        text: Optional[str] = None,
        cached_prompt: Optional[Dict[str, Any]] = None,
        padding: Union[bool, str, PaddingStrategy] = True,
        truncation: Union[bool, str, TruncationStrategy] = False,
        max_length: Optional[int] = None,
        return_tensors: Optional[Union[str, TensorType]] = None,
        return_attention_mask: bool = True,
        **kwargs,
    ) -> BatchEncoding:
        """
        Main method to process one text script based on cached prompt. The function currently only supports single examples.

View on GitHub (pinned to 94da20d98b)

Solutions

Use process_input_with_cached_prompt(text, cached_prompt, ...) for every streaming chunk, threading its returned cached_prompt into the next call.
If you do not need streaming, switch to VibeVoiceProcessor, whose __call__ works normally.
Wrap the streaming processor behind your own facade so generic callers never hit __call__.

Example fix

# before
enc = processor(text=prompt, audio=voice)  # NotImplementedError

# after
enc, cached = None, None
result = processor.process_input_with_cached_prompt(text=prompt, cached_prompt=None)
# next chunk:
result = processor.process_input_with_cached_prompt(text=next_text,
    cached_prompt=result.cached_prompt)

Defensive patterns

Strategy: validation

Validate before calling

from vibevoice.processor import VibeVoiceStreamingProcessor
# route by capability, not by name
if isinstance(processor, VibeVoiceStreamingProcessor):
    result = processor.process_input_with_cached_prompt(text=text, cached_prompt=cached)
else:
    result = processor(text=text)

Type guard

def is_streaming_processor(p) -> bool:
    from vibevoice.processor import VibeVoiceStreamingProcessor
    return isinstance(p, VibeVoiceStreamingProcessor)

Try / catch

try:
    enc = processor(text=text)
except NotImplementedError as e:
    if 'process_input_with_cached_prompt' in str(e):
        enc = processor.process_input_with_cached_prompt(text=text, cached_prompt=None)
    else:
        raise

Prevention

Call process_input_with_cached_prompt explicitly for streaming processors; never __call__.
Use VibeVoiceProcessor when you want one-shot __call__ semantics.
Gate generic inference-server code on processor type before invoking.

When it happens

Trigger: Calling the processor instance directly — processor(text=..., audio=...) — after loading VibeVoiceStreamingProcessor, usually because generic example code (written for VibeVoiceProcessor) was reused verbatim.

Common situations: Copy-pasting quickstart snippets that use the non-streaming processor; frameworks like inference servers that introspect and invoke __call__ uniformly across processor types.

Related errors

AI-assisted analysis of microsoft/VibeVoice@94da20d98b (2026-08-15). Data as JSON: /api/errors/7bd164fa64e70550. Report an issue: GitHub.