preprocess.py 24.9 KB
Newer Older
1
2
# SPDX-License-Identifier: Apache-2.0

3
import asyncio
4
from typing import List, Mapping, Optional, Union
5
6
7
8
9
10

from typing_extensions import assert_never

from vllm.config import ModelConfig
from vllm.logger import init_logger
from vllm.lora.request import LoRARequest
11
from vllm.multimodal import MULTIMODAL_REGISTRY, MultiModalRegistry
12
from vllm.multimodal.inputs import MultiModalDataDict, MultiModalInputs
13
14
15
from vllm.prompt_adapter.request import PromptAdapterRequest
from vllm.transformers_utils.tokenizer_group import BaseTokenizerGroup

16
17
from .data import (DecoderOnlyInputs, EncoderDecoderInputs, ProcessorInputs,
                   PromptType, SingletonInputs, SingletonPrompt, token_inputs)
18
19
20
21
22
23
24
25
26
27
28
from .parse import is_explicit_encoder_decoder_prompt, parse_singleton_prompt

logger = init_logger(__name__)


class InputPreprocessor:

    def __init__(
        self,
        model_config: ModelConfig,
        tokenizer: Optional[BaseTokenizerGroup],
29
        mm_registry: MultiModalRegistry = MULTIMODAL_REGISTRY,
30
31
32
33
34
    ) -> None:
        super().__init__()

        self.model_config = model_config
        self.tokenizer = tokenizer
35
        self.mm_registry = mm_registry
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70

    def get_tokenizer_group(self) -> BaseTokenizerGroup:
        if self.tokenizer is None:
            raise ValueError("You cannot pass text prompts when "
                             "`skip_tokenizer_init` is True")

        return self.tokenizer

    def get_bos_token_id(self,
                         lora_request: Optional[LoRARequest] = None
                         ) -> Optional[int]:
        if self.tokenizer is None:
            logger.warning("Using None for BOS token id because tokenizer "
                           "is not initialized")
            return None

        return self.tokenizer.get_lora_tokenizer(lora_request).bos_token_id

    def get_eos_token_id(self,
                         lora_request: Optional[LoRARequest] = None
                         ) -> Optional[int]:
        if self.tokenizer is None:
            logger.warning("Using None for EOS token id because tokenizer "
                           "is not initialized")
            return None

        return self.tokenizer.get_lora_tokenizer(lora_request).eos_token_id

    def get_decoder_start_token_id(self) -> Optional[int]:
        '''
        Obtain the decoder start token id employed by an encoder/decoder
        model. Returns None for non-encoder/decoder models or if the
        model config is unavailable.
        '''

71
        if not self.model_config.is_encoder_decoder:
72
73
74
            logger.warning_once(
                "Using None for decoder start token id because "
                "this is not an encoder/decoder model.")
75
76
77
            return None

        if (self.model_config is None or self.model_config.hf_config is None):
78
79
80
            logger.warning_once(
                "Using None for decoder start token id because "
                "model config is not available.")
81
82
83
84
85
            return None

        dec_start_token_id = getattr(self.model_config.hf_config,
                                     'decoder_start_token_id', None)
        if dec_start_token_id is None:
86
87
88
89
            logger.warning_once(
                "Falling back on <BOS> for decoder start token "
                "id because decoder start token id is not "
                "available.")
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
            dec_start_token_id = self.get_bos_token_id()

        return dec_start_token_id

    def _get_default_enc_dec_decoder_prompt(self) -> List[int]:
        '''
        Specifically for encoder/decoder models:
        generate a default decoder prompt for when
        the user specifies only the encoder prompt.

        Encoder/decoder models utilize the decoder
        prompt in different ways; as new models are
        added, it is intended that this function
        will be extended to produce differing
        default decoder prompts, depending on the
        model variety.

        Absent a special case, the default behavior
        of this method is to mirror the behavior of
        the HuggingFace (HF) GenerationMixin for a None
        decoder prompt, which is to employ a logit processor
        setting to force the first decoded token to be <BOS>.
        Here, this behavior is approximated by having the
        "default" decoder prompt be <BOS>.

        However, it is possible that in the future
116
        other models may have different or more
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
        complex logic for the default decoder prompt.
        This motivates having a special helper method
        for default decoder prompts.

        Returns:

        * prompt_token_ids
        '''

        bos_token_id = self.get_bos_token_id()
        assert bos_token_id is not None
        return [bos_token_id]

    def _prepare_decoder_input_ids_for_generation(
        self,
        decoder_input_ids: Optional[List[int]],
    ) -> List[int]:
        """
        Prepares `decoder_input_ids` for generation with encoder-decoder models.

        Based on

        https://github.com/huggingface/transformers/blob/
        4037a2b5b1278736e566aec12e169100275545ea/
        src/transformers/generation/utils.py

        specifically GenerationMixin._prepare_decoder_input_ids_for_generation()

        Arguments:

        * decoder_input_ids: input token ids to preprocess

        Returns:

        * Processed token list
        """

        decoder_start_token_id = self.get_decoder_start_token_id()
        assert decoder_start_token_id is not None

        if decoder_input_ids is None:
            # no decoder prompt input ->
            # use decoder_start_token_id as decoder_input_ids
            decoder_input_ids = self._get_default_enc_dec_decoder_prompt()

162
163
        if (len(decoder_input_ids) == 0
                or decoder_input_ids[0] != decoder_start_token_id):
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
            decoder_input_ids = [decoder_start_token_id] + decoder_input_ids

        return decoder_input_ids

    def _apply_prompt_adapter(
        self,
        prompt_token_ids: List[int],
        prompt_adapter_request: Optional[PromptAdapterRequest],
    ) -> List[int]:
        if prompt_adapter_request:
            prompt_token_ids = (
                [0] * prompt_adapter_request.prompt_adapter_num_virtual_tokens
                + prompt_token_ids)

        return prompt_token_ids

    def _tokenize_prompt(
        self,
        prompt: str,
        request_id: str,
        lora_request: Optional[LoRARequest],
    ) -> List[int]:
        """
        Apply the model's tokenizer to a text prompt, returning the
        corresponding token IDs.
        """
        tokenizer = self.get_tokenizer_group()
191
192
193
194
195
196
        add_special_tokens = None
        if self.model_config.hf_config.model_type == "whisper":
            # For Whisper, special tokens should be provided by the user based
            # on the task and language of their request. Also needed to avoid
            # appending an EOS token to the prompt which disrupts generation.
            add_special_tokens = False
197
198
199
200
201
202

        if (self.model_config.encoder_config is not None
                and self.model_config.encoder_config.get(
                    "do_lower_case", False)):
            prompt = prompt.lower()

203
204
        return tokenizer.encode(request_id=request_id,
                                prompt=prompt,
205
206
                                lora_request=lora_request,
                                add_special_tokens=add_special_tokens)
207
208
209
210
211
212
213
214
215

    async def _tokenize_prompt_async(
        self,
        prompt: str,
        request_id: str,
        lora_request: Optional[LoRARequest],
    ) -> List[int]:
        """Async version of :meth:`_tokenize_prompt`."""
        tokenizer = self.get_tokenizer_group()
216
217
218
219
220
221
222
223
224
225
226
        add_special_tokens = None
        if self.model_config.hf_config.model_type == "whisper":
            # For Whisper, special tokens should be provided by the user based
            # on the task and language of their request. Also needed to avoid
            # appending an EOS token to the prompt which disrupts generation.
            add_special_tokens = False
        return await tokenizer.encode_async(
            request_id=request_id,
            prompt=prompt,
            lora_request=lora_request,
            add_special_tokens=add_special_tokens)
227

228
229
230
231
232
233
234
235
236
237
    def _can_process_multimodal(self) -> bool:
        model_config = self.model_config

        if not model_config.is_multimodal_model:
            raise ValueError("Your model does not support multi-modal inputs")

        # Interim measure so we can handle models that have yet to be
        # updated to use the new multi-modal processor
        can_process_multimodal = self.mm_registry.has_processor(model_config)
        if not can_process_multimodal:
238
            logger.info_once(
239
240
241
242
243
244
245
246
247
248
249
250
251
                "Your model uses the legacy input pipeline instead of the new "
                "multi-modal processor. Please note that the legacy pipeline "
                "will be removed in a future release. For more details, see: "
                "https://github.com/vllm-project/vllm/issues/10114")

        return can_process_multimodal

    def _process_multimodal(
        self,
        prompt: Union[str, List[int]],
        mm_data: MultiModalDataDict,
        mm_processor_kwargs: Optional[Mapping[str, object]],
        lora_request: Optional[LoRARequest],
252
    ) -> MultiModalInputs:
253
254
255
256
257
258
259
260
261
262
        """
        Apply the model's multi-modal processor to a multi-modal prompt,
        returning the corresponding token IDs and metadata.
        """
        tokenizer_group = self.get_tokenizer_group()
        tokenizer = tokenizer_group.get_lora_tokenizer(lora_request)

        mm_processor = self.mm_registry.create_processor(
            self.model_config, tokenizer)

Kevin H. Luu's avatar
Kevin H. Luu committed
263
264
265
        if isinstance(prompt, list):
            prompt = tokenizer.decode(prompt)

266
267
268
269
270
271
272
273
274
275
276
        if mm_processor_kwargs is None:
            mm_processor_kwargs = {}

        return mm_processor.apply(prompt, mm_data, mm_processor_kwargs)

    async def _process_multimodal_async(
        self,
        prompt: Union[str, List[int]],
        mm_data: MultiModalDataDict,
        mm_processor_kwargs: Optional[Mapping[str, object]],
        lora_request: Optional[LoRARequest],
277
    ) -> MultiModalInputs:
278
279
280
281
282
283
284
285
286
287
288
289
        """Async version of :meth:`_process_multimodal`."""
        tokenizer_group = self.get_tokenizer_group()
        tokenizer = await tokenizer_group.get_lora_tokenizer_async(lora_request
                                                                   )

        mm_processor = self.mm_registry.create_processor(
            self.model_config, tokenizer)
        if mm_processor_kwargs is None:
            mm_processor_kwargs = {}

        return mm_processor.apply(prompt, mm_data, mm_processor_kwargs)

290
    def _prompt_to_llm_inputs(
291
        self,
292
        prompt: SingletonPrompt,
293
294
        request_id: str,
        lora_request: Optional[LoRARequest] = None,
295
    ) -> SingletonInputs:
296
297
        """
        Extract the singleton inputs from a prompt.
298
299
300
301

        Arguments:

        * request_id
302
        * prompt: single encoder or decoder input prompt
303
304
305
306
        * lora_request: this is only valid for decoder prompts

        Returns:

307
308
        * :class:`SingletonInputs` instance
        """
309
        parsed = parse_singleton_prompt(prompt)
310
311

        if parsed["type"] == "str":
312
            prompt_text = parsed["content"]
313
            prompt_token_ids = self._tokenize_prompt(
314
                prompt_text,
315
316
317
                request_id=request_id,
                lora_request=lora_request,
            )
318
319
320
321
322
323
324
325
326
327

            return token_inputs(
                prompt=prompt_text,
                prompt_token_ids=prompt_token_ids,
            )

        if parsed["type"] == "tokens":
            tokens_content = parsed["content"]

            prompt_token_ids = tokens_content["prompt_token_ids"]
328
            token_type_ids = tokens_content.get("token_type_ids")
329
330
331
            multi_modal_data = tokens_content.get("multi_modal_data")
            mm_processor_kwargs = tokens_content.get("mm_processor_kwargs")

332
333
334
335
336
337
338
339
            if multi_modal_data is not None and self._can_process_multimodal():
                return self._process_multimodal(
                    prompt_token_ids,
                    multi_modal_data,
                    mm_processor_kwargs,
                    lora_request=lora_request,
                )

340
341
            return token_inputs(
                prompt_token_ids=prompt_token_ids,
342
                token_type_ids=token_type_ids,
343
344
345
346
347
348
349
350
                multi_modal_data=multi_modal_data,
                mm_processor_kwargs=mm_processor_kwargs,
            )

        if parsed["type"] == "text":
            text_content = parsed["content"]

            prompt_text = text_content["prompt"]
351
352
353
354
355
356
357
358
359
360
361
            multi_modal_data = text_content.get("multi_modal_data")
            mm_processor_kwargs = text_content.get("mm_processor_kwargs")

            if multi_modal_data is not None and self._can_process_multimodal():
                return self._process_multimodal(
                    prompt_text,
                    multi_modal_data,
                    mm_processor_kwargs,
                    lora_request=lora_request,
                )

362
            prompt_token_ids = self._tokenize_prompt(
363
                prompt_text,
364
365
366
                request_id=request_id,
                lora_request=lora_request,
            )
367
368
369
370
371
372
373

            return token_inputs(
                prompt=prompt_text,
                prompt_token_ids=prompt_token_ids,
                multi_modal_data=multi_modal_data,
                mm_processor_kwargs=mm_processor_kwargs,
            )
374

375
        assert_never(parsed)
376

377
    async def _prompt_to_llm_inputs_async(
378
        self,
379
        prompt: SingletonPrompt,
380
381
        request_id: str,
        lora_request: Optional[LoRARequest] = None,
382
    ) -> SingletonInputs:
383
        """Async version of :meth:`_extract_prompt_components`."""
384
        parsed = parse_singleton_prompt(prompt)
385
386

        if parsed["type"] == "str":
387
            prompt_text = parsed["content"]
388
            prompt_token_ids = await self._tokenize_prompt_async(
389
                prompt_text,
390
391
392
                request_id=request_id,
                lora_request=lora_request,
            )
393
394
395
396
397
398
399
400
401
402
403
404
405

            return token_inputs(
                prompt=prompt_text,
                prompt_token_ids=prompt_token_ids,
            )

        if parsed["type"] == "tokens":
            tokens_content = parsed["content"]

            prompt_token_ids = tokens_content["prompt_token_ids"]
            multi_modal_data = tokens_content.get("multi_modal_data")
            mm_processor_kwargs = tokens_content.get("mm_processor_kwargs")

406
407
408
409
410
411
412
413
            if multi_modal_data is not None and self._can_process_multimodal():
                return await self._process_multimodal_async(
                    prompt_token_ids,
                    multi_modal_data,
                    mm_processor_kwargs,
                    lora_request=lora_request,
                )

414
415
416
417
418
419
420
421
422
423
            return token_inputs(
                prompt_token_ids=prompt_token_ids,
                multi_modal_data=multi_modal_data,
                mm_processor_kwargs=mm_processor_kwargs,
            )

        if parsed["type"] == "text":
            text_content = parsed["content"]

            prompt_text = text_content["prompt"]
424
425
426
427
428
429
430
431
432
433
434
            multi_modal_data = text_content.get("multi_modal_data")
            mm_processor_kwargs = text_content.get("mm_processor_kwargs")

            if multi_modal_data is not None and self._can_process_multimodal():
                return await self._process_multimodal_async(
                    prompt_text,
                    multi_modal_data,
                    mm_processor_kwargs,
                    lora_request=lora_request,
                )

435
            prompt_token_ids = await self._tokenize_prompt_async(
436
                prompt_text,
437
438
439
                request_id=request_id,
                lora_request=lora_request,
            )
440
441
442
443
444
445
446

            return token_inputs(
                prompt=prompt_text,
                prompt_token_ids=prompt_token_ids,
                multi_modal_data=multi_modal_data,
                mm_processor_kwargs=mm_processor_kwargs,
            )
447

448
        assert_never(parsed)
449
450
451

    def _build_enc_dec_llm_inputs(
        self,
452
453
        encoder_inputs: SingletonInputs,
        decoder_inputs: Optional[SingletonInputs],
454
    ) -> EncoderDecoderInputs:
455
456
        if (encoder_inputs["type"] == "token"
                or encoder_inputs["type"] == "multimodal"):
457
458
            pass
        else:
459
            assert_never(encoder_inputs)  # type: ignore[arg-type]
460
461

        if decoder_inputs is None:
462
463
464
465
466
467
468
469
470
            if self.model_config.hf_config.model_type == "whisper":
                # For Whisper models, the text prompt should go to the decoder.
                # If no explicit encoder/decoder inputs, then copy the prompt
                # from the encoder to the decoder. The encoder tokens are later
                # overridden by the audio features.
                dec_token_ids = encoder_inputs["prompt_token_ids"].copy()
            else:
                dec_token_ids = self._prepare_decoder_input_ids_for_generation(
                    None)
471
            decoder_inputs = token_inputs(dec_token_ids)
472
473
        elif (decoder_inputs["type"] == "token"
              or decoder_inputs["type"] == "multimodal"):
474
475
476
477
478
479
480
481
            dec_token_ids = self._prepare_decoder_input_ids_for_generation(
                decoder_inputs["prompt_token_ids"])
            decoder_inputs["prompt_token_ids"] = dec_token_ids

            if "multi_modal_data" in decoder_inputs:
                raise ValueError("Multi-modal decoder inputs of encoder-"
                                 "decoder models are not supported yet")
        else:
482
            assert_never(encoder_inputs)  # type: ignore[arg-type]
483

484
        return EncoderDecoderInputs(
485
486
            encoder=encoder_inputs,
            decoder=decoder_inputs,
487
488
489
490
        )

    def _process_encoder_decoder_prompt(
        self,
491
        prompt: PromptType,
492
        request_id: str,
493
    ) -> EncoderDecoderInputs:
494
        """
495
        For encoder/decoder models only:
496
        Process an input prompt into an :class:`EncoderDecoderInputs` instance.
497
498
499
500
501
502
503
504
505
506
507
508
509
510
511
512
513
514

        There are two types of input prompts:
        singleton prompts which carry only the
        encoder prompt, and explicit encoder/decoder
        prompts which carry both the encoder and the
        decoder prompts as member variables.

        This function handles the following scenarios:
        * Singleton encoder prompt: extract encoder prompt
          token ids & infer default decoder prompt token ids
        * Explicit encoder/decoder prompt: extract encoder
          and decoder prompt token ids

        Note that for Explicit encoder/decoder prompts,
        each sub-prompt (encoder or decoder prompt) can
        have any possible singleton type; thus this
        method relies on helper functions to obtain
        token ids for the sub-prompts.
515

516
517
        Arguments:

518
        * prompt: an input prompt
519
520
521
522
        * request_id

        Returns:

523
        * :class:`EncoderDecoderInputs` instance
524
        """
525
526
        encoder_inputs: SingletonInputs
        decoder_inputs: Optional[SingletonInputs]
527

528
        if is_explicit_encoder_decoder_prompt(prompt):
529
            encoder_inputs = self._prompt_to_llm_inputs(
530
                prompt["encoder_prompt"],
531
532
533
                request_id=request_id,
            )

534
            if (decoder_input := prompt["decoder_prompt"]) is None:
535
                decoder_inputs = None
536
            else:
537
                decoder_inputs = self._prompt_to_llm_inputs(
538
539
540
541
                    decoder_input,
                    request_id=request_id,
                )
        else:
542
            encoder_inputs = self._prompt_to_llm_inputs(
543
                prompt,
544
545
                request_id=request_id,
            )
546
547
548
549

            decoder_inputs = None

        return self._build_enc_dec_llm_inputs(encoder_inputs, decoder_inputs)
550
551
552

    async def _process_encoder_decoder_prompt_async(
        self,
553
        prompt: PromptType,
554
        request_id: str,
555
    ) -> EncoderDecoderInputs:
556
        """Async version of :meth:`_process_encoder_decoder_prompt`."""
557
558
        encoder_inputs: SingletonInputs
        decoder_inputs: Optional[SingletonInputs]
559

560
        if is_explicit_encoder_decoder_prompt(prompt):
561
            encoder_task = self._prompt_to_llm_inputs_async(
562
                prompt["encoder_prompt"],
563
564
565
                request_id=request_id,
            )

566
            if (decoder_input := prompt["decoder_prompt"]) is None:
567
568
                encoder_inputs = await encoder_task
                decoder_inputs = None
569
            else:
570
                decoder_task = self._prompt_to_llm_inputs_async(
571
572
573
574
                    decoder_input,
                    request_id=request_id,
                )

575
                encoder_inputs, decoder_inputs = await asyncio.gather(
576
577
                    encoder_task, decoder_task)
        else:
578
            encoder_inputs = await self._prompt_to_llm_inputs_async(
579
                prompt,
580
581
                request_id=request_id,
            )
582
583
584
585

            decoder_inputs = None

        return self._build_enc_dec_llm_inputs(encoder_inputs, decoder_inputs)
586
587
588

    def _build_decoder_only_llm_inputs(
        self,
589
        prompt_inputs: DecoderOnlyInputs,
590
        prompt_adapter_request: Optional[PromptAdapterRequest],
591
    ) -> DecoderOnlyInputs:
592
593
        if (prompt_inputs["type"] == "token"
                or prompt_inputs["type"] == "multimodal"):
594
595
596
597
598
            prompt_inputs["prompt_token_ids"] = self._apply_prompt_adapter(
                prompt_inputs["prompt_token_ids"],
                prompt_adapter_request=prompt_adapter_request,
            )
        else:
599
            assert_never(prompt_inputs)  # type: ignore[arg-type]
600

601
        return prompt_inputs
602
603
604

    def _process_decoder_only_prompt(
        self,
605
        prompt: SingletonPrompt,
606
607
608
        request_id: str,
        lora_request: Optional[LoRARequest] = None,
        prompt_adapter_request: Optional[PromptAdapterRequest] = None,
609
    ) -> DecoderOnlyInputs:
610
        """
611
        For decoder-only models:
612
        Process an input prompt into an :class:`DecoderOnlyInputs` instance.
613
614
615

        Arguments:

616
        * prompt: input prompt
617
618
619
620
621
622
        * request_id
        * lora_request
        * prompt_adapter_request

        Returns:

623
        * :class:`DecoderOnlyInputs` instance
624
        """
625

626
        prompt_comps = self._prompt_to_llm_inputs(
627
            prompt,
628
629
630
631
632
633
634
635
636
637
638
            request_id=request_id,
            lora_request=lora_request,
        )

        return self._build_decoder_only_llm_inputs(
            prompt_comps,
            prompt_adapter_request=prompt_adapter_request,
        )

    async def _process_decoder_only_prompt_async(
        self,
639
        prompt: SingletonPrompt,
640
641
642
        request_id: str,
        lora_request: Optional[LoRARequest] = None,
        prompt_adapter_request: Optional[PromptAdapterRequest] = None,
643
    ) -> DecoderOnlyInputs:
644
        """Async version of :meth:`_process_decoder_only_prompt`."""
645
        prompt_comps = await self._prompt_to_llm_inputs_async(
646
            prompt,
647
648
649
650
651
652
653
654
655
656
657
            request_id=request_id,
            lora_request=lora_request,
        )

        return self._build_decoder_only_llm_inputs(
            prompt_comps,
            prompt_adapter_request=prompt_adapter_request,
        )

    def preprocess(
        self,
658
        prompt: PromptType,
659
660
661
        request_id: str,
        lora_request: Optional[LoRARequest] = None,
        prompt_adapter_request: Optional[PromptAdapterRequest] = None,
662
    ) -> ProcessorInputs:
663
        """Preprocess the input prompt."""
664
        if self.model_config.is_encoder_decoder:
665
666
667
            # Encoder-decoder model requires special mapping of
            # input prompts to encoder & decoder
            return self._process_encoder_decoder_prompt(
668
                prompt,
669
670
671
                request_id=request_id,
            )

672
        if is_explicit_encoder_decoder_prompt(prompt):
673
674
675
676
677
            raise ValueError("Cannot pass encoder-decoder prompt "
                             "to decoder-only models")

        # Decoder-only operation
        return self._process_decoder_only_prompt(
678
            prompt,
679
680
681
682
683
684
685
            request_id=request_id,
            lora_request=lora_request,
            prompt_adapter_request=prompt_adapter_request,
        )

    async def preprocess_async(
        self,
686
        prompt: PromptType,
687
688
689
        request_id: str,
        lora_request: Optional[LoRARequest] = None,
        prompt_adapter_request: Optional[PromptAdapterRequest] = None,
690
    ) -> ProcessorInputs:
691
        """Async version of :meth:`preprocess`."""
692
        if self.model_config.is_encoder_decoder:
693
694
695
            # Encoder-decoder model requires special mapping of
            # input prompts to encoder & decoder
            return await self._process_encoder_decoder_prompt_async(
696
                prompt,
697
698
699
                request_id=request_id,
            )

700
        if is_explicit_encoder_decoder_prompt(prompt):
701
702
703
704
705
            raise ValueError("Cannot pass encoder-decoder prompt "
                             "to decoder-only models")

        # Decoder-only operation
        return await self._process_decoder_only_prompt_async(
706
            prompt,
707
708
709
710
            request_id=request_id,
            lora_request=lora_request,
            prompt_adapter_request=prompt_adapter_request,
        )