protocol.py 30.5 KB
Newer Older
1
2
# Adapted from
# https://github.com/lm-sys/FastChat/blob/168ccc29d3f7edc50823016105c024fe2282732a/fastchat/protocol/openai_api_protocol.py
Zhuohan Li's avatar
Zhuohan Li committed
3
import time
4
from argparse import Namespace
5
from typing import Any, Dict, List, Literal, Optional, Union
Zhuohan Li's avatar
Zhuohan Li committed
6

7
import torch
8
from openai.types.chat import ChatCompletionContentPartParam
9
from pydantic import BaseModel, ConfigDict, Field, model_validator
10
from typing_extensions import Annotated, Required, TypedDict
Zhuohan Li's avatar
Zhuohan Li committed
11

12
from vllm.entrypoints.chat_utils import ChatCompletionMessageParam
13
from vllm.entrypoints.openai.logits_processors import get_logits_processors
14
from vllm.pooling_params import PoolingParams
15
from vllm.sampling_params import LogitsProcessor, SamplingParams
16
from vllm.sequence import Logprob
17
from vllm.transformers_utils.tokenizer import AnyTokenizer
18
from vllm.utils import random_uuid
19

20
21
22
# torch is mocked during docs generation,
# so we have to provide the values as literals
_MOCK_LONG_INFO = Namespace(min=-9223372036854775808, max=9223372036854775807)
23
_LONG_INFO: Union["torch.iinfo", Namespace]
24
25
26
27
28
29
30
31
32
33
34
35
36
37

try:
    from sphinx.ext.autodoc.mock import _MockModule

    if isinstance(torch, _MockModule):
        _LONG_INFO = _MOCK_LONG_INFO
    else:
        _LONG_INFO = torch.iinfo(torch.long)
except ModuleNotFoundError:
    _LONG_INFO = torch.iinfo(torch.long)

assert _LONG_INFO.min == _MOCK_LONG_INFO.min
assert _LONG_INFO.max == _MOCK_LONG_INFO.max

Zhuohan Li's avatar
Zhuohan Li committed
38

39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
class CustomChatCompletionMessageParam(TypedDict, total=False):
    """Enables custom roles in the Chat Completion API."""
    role: Required[str]
    """The role of the message's author."""

    content: Union[str, List[ChatCompletionContentPartParam]]
    """The contents of the message."""

    name: str
    """An optional name for the participant.

    Provides the model information to differentiate between participants of the
    same role.
    """

    tool_call_id: Optional[str]

    tool_calls: Optional[List[dict]]


59
60
61
62
63
64
class OpenAIBaseModel(BaseModel):
    # OpenAI API does not allow extra fields
    model_config = ConfigDict(extra="forbid")


class ErrorResponse(OpenAIBaseModel):
Zhuohan Li's avatar
Zhuohan Li committed
65
66
67
68
    object: str = "error"
    message: str
    type: str
    param: Optional[str] = None
69
    code: int
Zhuohan Li's avatar
Zhuohan Li committed
70
71


72
class ModelPermission(OpenAIBaseModel):
Zhuohan Li's avatar
Zhuohan Li committed
73
74
75
76
77
78
79
80
81
82
83
    id: str = Field(default_factory=lambda: f"modelperm-{random_uuid()}")
    object: str = "model_permission"
    created: int = Field(default_factory=lambda: int(time.time()))
    allow_create_engine: bool = False
    allow_sampling: bool = True
    allow_logprobs: bool = True
    allow_search_indices: bool = False
    allow_view: bool = True
    allow_fine_tuning: bool = False
    organization: str = "*"
    group: Optional[str] = None
84
    is_blocking: bool = False
Zhuohan Li's avatar
Zhuohan Li committed
85
86


87
class ModelCard(OpenAIBaseModel):
Zhuohan Li's avatar
Zhuohan Li committed
88
89
90
    id: str
    object: str = "model"
    created: int = Field(default_factory=lambda: int(time.time()))
Woosuk Kwon's avatar
Woosuk Kwon committed
91
    owned_by: str = "vllm"
Zhuohan Li's avatar
Zhuohan Li committed
92
93
    root: Optional[str] = None
    parent: Optional[str] = None
94
    max_model_len: Optional[int] = None
Zhuohan Li's avatar
Zhuohan Li committed
95
96
97
    permission: List[ModelPermission] = Field(default_factory=list)


98
class ModelList(OpenAIBaseModel):
Zhuohan Li's avatar
Zhuohan Li committed
99
100
101
102
    object: str = "list"
    data: List[ModelCard] = Field(default_factory=list)


103
class UsageInfo(OpenAIBaseModel):
Zhuohan Li's avatar
Zhuohan Li committed
104
105
106
107
108
    prompt_tokens: int = 0
    total_tokens: int = 0
    completion_tokens: Optional[int] = 0


109
110
111
112
113
114
115
116
117
class JsonSchemaResponseFormat(OpenAIBaseModel):
    name: str
    description: Optional[str] = None
    # schema is the field in openai but that causes conflicts with pydantic so
    # instead use json_schema with an alias
    json_schema: Optional[Dict[str, Any]] = Field(default=None, alias='schema')
    strict: Optional[bool] = None


118
class ResponseFormat(OpenAIBaseModel):
119
120
121
    # type must be "json_schema", "json_object" or "text"
    type: Literal["text", "json_object", "json_schema"]
    json_schema: Optional[JsonSchemaResponseFormat] = None
122
123


124
class StreamOptions(OpenAIBaseModel):
125
126
    include_usage: Optional[bool] = True
    continuous_usage_stats: Optional[bool] = True
127
128


129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
class FunctionDefinition(OpenAIBaseModel):
    name: str
    description: Optional[str] = None
    parameters: Optional[Dict[str, Any]] = None


class ChatCompletionToolsParam(OpenAIBaseModel):
    type: Literal["function"] = "function"
    function: FunctionDefinition


class ChatCompletionNamedFunction(OpenAIBaseModel):
    name: str


class ChatCompletionNamedToolChoiceParam(OpenAIBaseModel):
    function: ChatCompletionNamedFunction
    type: Literal["function"] = "function"


149
class ChatCompletionRequest(OpenAIBaseModel):
150
151
    # Ordered by official OpenAI API documentation
    # https://platform.openai.com/docs/api-reference/chat/create
152
    messages: List[ChatCompletionMessageParam]
153
154
155
156
    model: str
    frequency_penalty: Optional[float] = 0.0
    logit_bias: Optional[Dict[str, float]] = None
    logprobs: Optional[bool] = False
157
    top_logprobs: Optional[int] = 0
158
    max_tokens: Optional[int] = None
159
160
161
    n: Optional[int] = 1
    presence_penalty: Optional[float] = 0.0
    response_format: Optional[ResponseFormat] = None
162
    seed: Optional[int] = Field(None, ge=_LONG_INFO.min, le=_LONG_INFO.max)
163
    stop: Optional[Union[str, List[str]]] = Field(default_factory=list)
Zhuohan Li's avatar
Zhuohan Li committed
164
    stream: Optional[bool] = False
165
    stream_options: Optional[StreamOptions] = None
166
167
    temperature: Optional[float] = 0.7
    top_p: Optional[float] = 1.0
168
    tools: Optional[List[ChatCompletionToolsParam]] = None
169
    tool_choice: Optional[Union[Literal["none"], Literal["auto"],
170
                                ChatCompletionNamedToolChoiceParam]] = "none"
171
172
173

    # NOTE this will be ignored by VLLM -- the model determines the behavior
    parallel_tool_calls: Optional[bool] = False
Zhuohan Li's avatar
Zhuohan Li committed
174
    user: Optional[str] = None
175
176

    # doc: begin-chat-completion-sampling-params
177
    best_of: Optional[int] = None
178
179
180
181
182
183
    use_beam_search: bool = False
    top_k: int = -1
    min_p: float = 0.0
    repetition_penalty: float = 1.0
    length_penalty: float = 1.0
    early_stopping: bool = False
184
    stop_token_ids: Optional[List[int]] = Field(default_factory=list)
185
186
187
188
189
190
    include_stop_str_in_output: bool = False
    ignore_eos: bool = False
    min_tokens: int = 0
    skip_special_tokens: bool = True
    spaces_between_special_tokens: bool = True
    truncate_prompt_tokens: Optional[Annotated[int, Field(ge=1)]] = None
191
    prompt_logprobs: Optional[int] = None
192
193
194
    # doc: end-chat-completion-sampling-params

    # doc: begin-chat-completion-extra-params
195
    echo: bool = Field(
196
197
198
199
200
        default=False,
        description=(
            "If true, the new message will be prepended with the last message "
            "if they belong to the same role."),
    )
201
    add_generation_prompt: bool = Field(
202
203
204
205
206
207
        default=True,
        description=
        ("If true, the generation prompt will be added to the chat template. "
         "This is a parameter used by chat template in tokenizer config of the "
         "model."),
    )
208
    add_special_tokens: bool = Field(
209
210
211
212
213
        default=False,
        description=(
            "If true, special tokens (e.g. BOS) will be added to the prompt "
            "on top of what is added by the chat template. "
            "For most models, the chat template takes care of adding the "
214
            "special tokens so this should be set to false (as is the "
215
216
            "default)."),
    )
217
218
219
220
221
222
223
224
225
226
227
228
229
    documents: Optional[List[Dict[str, str]]] = Field(
        default=None,
        description=
        ("A list of dicts representing documents that will be accessible to "
         "the model if it is performing RAG (retrieval-augmented generation)."
         " If the template does not support RAG, this argument will have no "
         "effect. We recommend that each document should be a dict containing "
         "\"title\" and \"text\" keys."),
    )
    chat_template: Optional[str] = Field(
        default=None,
        description=(
            "A Jinja template to use for this conversion. "
230
231
232
            "As of transformers v4.44, default chat template is no longer "
            "allowed, so you must provide a chat template if the tokenizer "
            "does not define one."),
233
234
235
236
237
238
    )
    chat_template_kwargs: Optional[Dict[str, Any]] = Field(
        default=None,
        description=("Additional kwargs to pass to the template renderer. "
                     "Will be accessible by the chat template."),
    )
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
    guided_json: Optional[Union[str, dict, BaseModel]] = Field(
        default=None,
        description=("If specified, the output will follow the JSON schema."),
    )
    guided_regex: Optional[str] = Field(
        default=None,
        description=(
            "If specified, the output will follow the regex pattern."),
    )
    guided_choice: Optional[List[str]] = Field(
        default=None,
        description=(
            "If specified, the output will be exactly one of the choices."),
    )
    guided_grammar: Optional[str] = Field(
        default=None,
        description=(
            "If specified, the output will follow the context free grammar."),
    )
258
259
260
261
262
263
    guided_decoding_backend: Optional[str] = Field(
        default=None,
        description=(
            "If specified, will override the default guided decoding backend "
            "of the server for this specific request. If set, must be either "
            "'outlines' / 'lm-format-enforcer'"))
264
265
266
267
268
    guided_whitespace_pattern: Optional[str] = Field(
        default=None,
        description=(
            "If specified, will override the default whitespace pattern "
            "for guided json decoding."))
269
270

    # doc: end-chat-completion-extra-params
Zhuohan Li's avatar
Zhuohan Li committed
271

272
    def to_sampling_params(
273
            self, tokenizer: AnyTokenizer,
274
275
276
277
278
            guided_decode_logits_processor: Optional[LogitsProcessor],
            default_max_tokens: int) -> SamplingParams:
        max_tokens = self.max_tokens
        if max_tokens is None:
            max_tokens = default_max_tokens
279

280
281
282
283
        prompt_logprobs = self.prompt_logprobs
        if prompt_logprobs is None and self.echo:
            prompt_logprobs = self.top_logprobs

284
        # We now allow logprobs being true without top_logrobs.
285
286
287
288
289
        logits_processors = get_logits_processors(
            logit_bias=self.logit_bias,
            allowed_token_ids=None,
            tokenizer=tokenizer,
        )
290
291
        if guided_decode_logits_processor:
            logits_processors.append(guided_decode_logits_processor)
292

293
        return SamplingParams.from_optional(
294
            n=self.n,
295
            best_of=self.best_of,
296
297
298
299
300
            presence_penalty=self.presence_penalty,
            frequency_penalty=self.frequency_penalty,
            repetition_penalty=self.repetition_penalty,
            temperature=self.temperature,
            top_p=self.top_p,
301
            top_k=self.top_k,
302
            min_p=self.min_p,
Nick Hill's avatar
Nick Hill committed
303
            seed=self.seed,
304
305
            stop=self.stop,
            stop_token_ids=self.stop_token_ids,
306
            logprobs=self.top_logprobs if self.logprobs else None,
307
            prompt_logprobs=prompt_logprobs,
308
            ignore_eos=self.ignore_eos,
309
            max_tokens=max_tokens,
310
            min_tokens=self.min_tokens,
311
            use_beam_search=self.use_beam_search,
312
            early_stopping=self.early_stopping,
313
314
            skip_special_tokens=self.skip_special_tokens,
            spaces_between_special_tokens=self.spaces_between_special_tokens,
315
316
            include_stop_str_in_output=self.include_stop_str_in_output,
            length_penalty=self.length_penalty,
317
            logits_processors=logits_processors,
318
            truncate_prompt_tokens=self.truncate_prompt_tokens,
319
320
        )

321
    @model_validator(mode="before")
322
    @classmethod
323
324
    def validate_stream_options(cls, data):
        if data.get("stream_options") and not data.get("stream"):
325
            raise ValueError(
326
327
328
329
330
331
332
333
334
335
336
337
338
339
340
341
342
343
344
345
346
347
348
349
350
                "Stream options can only be defined when `stream=True`.")

        return data

    @model_validator(mode="before")
    @classmethod
    def check_logprobs(cls, data):
        if (prompt_logprobs := data.get("prompt_logprobs")) is not None:
            if data.get("stream") and prompt_logprobs > 0:
                raise ValueError(
                    "`prompt_logprobs` are not available when `stream=True`.")

            if prompt_logprobs < 0:
                raise ValueError("`prompt_logprobs` must be a positive value.")

        if (top_logprobs := data.get("top_logprobs")) is not None:
            if top_logprobs < 0:
                raise ValueError("`top_logprobs` must be a positive value.")

            if not data.get("logprobs"):
                raise ValueError(
                    "when using `top_logprobs`, `logprobs` must be set to true."
                )

        return data
351

352
353
354
    @model_validator(mode="before")
    @classmethod
    def check_guided_decoding_count(cls, data):
355
356
357
        if isinstance(data, ValueError):
            raise data

358
359
360
361
362
        guide_count = sum([
            "guided_json" in data and data["guided_json"] is not None,
            "guided_regex" in data and data["guided_regex"] is not None,
            "guided_choice" in data and data["guided_choice"] is not None
        ])
363
        # you can only use one kind of guided decoding
364
365
366
367
        if guide_count > 1:
            raise ValueError(
                "You can only use one kind of guided decoding "
                "('guided_json', 'guided_regex' or 'guided_choice').")
368
        # you can only either use guided decoding or tools, not both
369
370
        if guide_count > 1 and data.get("tool_choice",
                                        "none") not in ("none", "auto"):
371
372
373
374
375
376
            raise ValueError(
                "You can only either use guided decoding or tools, not both.")
        return data

    @model_validator(mode="before")
    @classmethod
377
378
379
380
381
382
383
384
385
386
387
    def check_tool_usage(cls, data):

        # if "tool_choice" is not specified but tools are provided,
        # default to "auto" tool_choice
        if "tool_choice" not in data and "tools" in data:
            data["tool_choice"] = "auto"

        # if "tool_choice" is specified -- validation
        if "tool_choice" in data:

            # ensure that if "tool choice" is specified, tools are present
388
389
390
            if "tools" not in data or data["tools"] is None:
                raise ValueError(
                    "When using `tool_choice`, `tools` must be set.")
391
392
393
394
395
396
397
398
399
400
401
402
403
404
405
406
407
408
409
410
411
412
413
414
415
416
417
418
419
420
421
422
423

            # make sure that tool choice is either a named tool
            # OR that it's set to "auto"
            if data["tool_choice"] != "auto" and not isinstance(
                    data["tool_choice"], dict):
                raise ValueError(
                    "`tool_choice` must either be a named tool or \"auto\". "
                    "`tool_choice=\"none\" is not supported.")

            # ensure that if "tool_choice" is specified as an object,
            # it matches a valid tool
            if isinstance(data["tool_choice"], dict):
                valid_tool = False
                specified_function = data["tool_choice"]["function"]
                if not specified_function:
                    raise ValueError(
                        "Incorrectly formatted `tool_choice`. Should be like "
                        "`{\"type\": \"function\","
                        " \"function\": {\"name\": \"my_function\"}}`")
                specified_function_name = specified_function["name"]
                if not specified_function_name:
                    raise ValueError(
                        "Incorrectly formatted `tool_choice`. Should be like "
                        "`{\"type\": \"function\", "
                        "\"function\": {\"name\": \"my_function\"}}`")
                for tool in data["tools"]:
                    if tool["function"]["name"] == specified_function_name:
                        valid_tool = True
                        break
                if not valid_tool:
                    raise ValueError(
                        "The tool specified in `tool_choice` does not match any"
                        " of the specified `tools`")
424
425
        return data

Zhuohan Li's avatar
Zhuohan Li committed
426

427
class CompletionRequest(OpenAIBaseModel):
428
429
    # Ordered by official OpenAI API documentation
    # https://platform.openai.com/docs/api-reference/completions/create
Zhuohan Li's avatar
Zhuohan Li committed
430
    model: str
431
    prompt: Union[List[int], List[List[int]], str, List[str]]
432
    best_of: Optional[int] = None
Zhuohan Li's avatar
Zhuohan Li committed
433
434
435
    echo: Optional[bool] = False
    frequency_penalty: Optional[float] = 0.0
    logit_bias: Optional[Dict[str, float]] = None
436
437
    logprobs: Optional[int] = None
    max_tokens: Optional[int] = 16
438
    n: int = 1
439
    presence_penalty: Optional[float] = 0.0
440
    seed: Optional[int] = Field(None, ge=_LONG_INFO.min, le=_LONG_INFO.max)
441
442
    stop: Optional[Union[str, List[str]]] = Field(default_factory=list)
    stream: Optional[bool] = False
443
    stream_options: Optional[StreamOptions] = None
444
445
446
    suffix: Optional[str] = None
    temperature: Optional[float] = 1.0
    top_p: Optional[float] = 1.0
Zhuohan Li's avatar
Zhuohan Li committed
447
    user: Optional[str] = None
448
449

    # doc: begin-completion-sampling-params
450
451
452
453
454
455
    use_beam_search: bool = False
    top_k: int = -1
    min_p: float = 0.0
    repetition_penalty: float = 1.0
    length_penalty: float = 1.0
    early_stopping: bool = False
456
    stop_token_ids: Optional[List[int]] = Field(default_factory=list)
457
458
459
460
461
    include_stop_str_in_output: bool = False
    ignore_eos: bool = False
    min_tokens: int = 0
    skip_special_tokens: bool = True
    spaces_between_special_tokens: bool = True
462
    truncate_prompt_tokens: Optional[Annotated[int, Field(ge=1)]] = None
463
    allowed_token_ids: Optional[List[int]] = None
464
    prompt_logprobs: Optional[int] = None
465
466
467
    # doc: end-completion-sampling-params

    # doc: begin-completion-extra-params
468
469
    add_special_tokens: bool = Field(
        default=True,
470
        description=(
471
472
            "If true (the default), special tokens (e.g. BOS) will be added to "
            "the prompt."),
473
474
475
476
477
478
479
480
481
482
    )
    response_format: Optional[ResponseFormat] = Field(
        default=None,
        description=
        ("Similar to chat completion, this parameter specifies the format of "
         "output. Only {'type': 'json_object'} or {'type': 'text' } is "
         "supported."),
    )
    guided_json: Optional[Union[str, dict, BaseModel]] = Field(
        default=None,
483
        description="If specified, the output will follow the JSON schema.",
484
485
486
487
488
489
490
491
492
493
494
495
496
497
498
499
    )
    guided_regex: Optional[str] = Field(
        default=None,
        description=(
            "If specified, the output will follow the regex pattern."),
    )
    guided_choice: Optional[List[str]] = Field(
        default=None,
        description=(
            "If specified, the output will be exactly one of the choices."),
    )
    guided_grammar: Optional[str] = Field(
        default=None,
        description=(
            "If specified, the output will follow the context free grammar."),
    )
500
501
502
503
504
505
    guided_decoding_backend: Optional[str] = Field(
        default=None,
        description=(
            "If specified, will override the default guided decoding backend "
            "of the server for this specific request. If set, must be one of "
            "'outlines' / 'lm-format-enforcer'"))
506
507
508
509
510
    guided_whitespace_pattern: Optional[str] = Field(
        default=None,
        description=(
            "If specified, will override the default whitespace pattern "
            "for guided json decoding."))
511
512

    # doc: end-completion-extra-params
Zhuohan Li's avatar
Zhuohan Li committed
513

514
    def to_sampling_params(
515
            self, tokenizer: AnyTokenizer,
516
517
518
519
520
521
            guided_decode_logits_processor: Optional[LogitsProcessor],
            default_max_tokens: int) -> SamplingParams:
        max_tokens = self.max_tokens
        if max_tokens is None:
            max_tokens = default_max_tokens

522
523
524
525
        prompt_logprobs = self.prompt_logprobs
        if prompt_logprobs is None and self.echo:
            prompt_logprobs = self.logprobs

526
527
        echo_without_generation = self.echo and self.max_tokens == 0

528
529
530
531
532
        logits_processors = get_logits_processors(
            logit_bias=self.logit_bias,
            allowed_token_ids=self.allowed_token_ids,
            tokenizer=tokenizer,
        )
533
534
        if guided_decode_logits_processor:
            logits_processors.append(guided_decode_logits_processor)
535

536
        return SamplingParams.from_optional(
537
538
539
540
541
542
543
544
545
            n=self.n,
            best_of=self.best_of,
            presence_penalty=self.presence_penalty,
            frequency_penalty=self.frequency_penalty,
            repetition_penalty=self.repetition_penalty,
            temperature=self.temperature,
            top_p=self.top_p,
            top_k=self.top_k,
            min_p=self.min_p,
Nick Hill's avatar
Nick Hill committed
546
            seed=self.seed,
547
548
            stop=self.stop,
            stop_token_ids=self.stop_token_ids,
549
            logprobs=self.logprobs,
550
            ignore_eos=self.ignore_eos,
551
            max_tokens=max_tokens if not echo_without_generation else 1,
552
            min_tokens=self.min_tokens,
553
            use_beam_search=self.use_beam_search,
554
            early_stopping=self.early_stopping,
555
            prompt_logprobs=prompt_logprobs,
556
            skip_special_tokens=self.skip_special_tokens,
557
            spaces_between_special_tokens=self.spaces_between_special_tokens,
558
559
            include_stop_str_in_output=self.include_stop_str_in_output,
            length_penalty=self.length_penalty,
560
            logits_processors=logits_processors,
561
            truncate_prompt_tokens=self.truncate_prompt_tokens,
562
563
        )

564
565
566
567
568
569
570
571
572
573
574
575
576
577
    @model_validator(mode="before")
    @classmethod
    def check_guided_decoding_count(cls, data):
        guide_count = sum([
            "guided_json" in data and data["guided_json"] is not None,
            "guided_regex" in data and data["guided_regex"] is not None,
            "guided_choice" in data and data["guided_choice"] is not None
        ])
        if guide_count > 1:
            raise ValueError(
                "You can only use one kind of guided decoding "
                "('guided_json', 'guided_regex' or 'guided_choice').")
        return data

578
579
580
    @model_validator(mode="before")
    @classmethod
    def check_logprobs(cls, data):
581
582
583
584
585
586
587
588
589
590
591
        if (prompt_logprobs := data.get("prompt_logprobs")) is not None:
            if data.get("stream") and prompt_logprobs > 0:
                raise ValueError(
                    "`prompt_logprobs` are not available when `stream=True`.")

            if prompt_logprobs < 0:
                raise ValueError("`prompt_logprobs` must be a positive value.")

        if (logprobs := data.get("logprobs")) is not None and logprobs < 0:
            raise ValueError("`logprobs` must be a positive value.")

592
593
        return data

594
595
596
597
598
    @model_validator(mode="before")
    @classmethod
    def validate_stream_options(cls, data):
        if data.get("stream_options") and not data.get("stream"):
            raise ValueError(
599
600
                "Stream options can only be defined when `stream=True`.")

601
602
        return data

Zhuohan Li's avatar
Zhuohan Li committed
603

604
class EmbeddingRequest(OpenAIBaseModel):
605
606
607
608
    # Ordered by official OpenAI API documentation
    # https://platform.openai.com/docs/api-reference/embeddings
    model: str
    input: Union[List[int], List[List[int]], str, List[str]]
609
    encoding_format: Literal["float", "base64"] = "float"
610
611
612
613
614
615
616
617
618
619
620
621
    dimensions: Optional[int] = None
    user: Optional[str] = None

    # doc: begin-embedding-pooling-params
    additional_data: Optional[Any] = None

    # doc: end-embedding-pooling-params

    def to_pooling_params(self):
        return PoolingParams(additional_data=self.additional_data)


622
class CompletionLogProbs(OpenAIBaseModel):
Zhuohan Li's avatar
Zhuohan Li committed
623
624
625
    text_offset: List[int] = Field(default_factory=list)
    token_logprobs: List[Optional[float]] = Field(default_factory=list)
    tokens: List[str] = Field(default_factory=list)
626
627
    top_logprobs: List[Optional[Dict[str,
                                     float]]] = Field(default_factory=list)
Zhuohan Li's avatar
Zhuohan Li committed
628
629


630
class CompletionResponseChoice(OpenAIBaseModel):
Zhuohan Li's avatar
Zhuohan Li committed
631
632
    index: int
    text: str
633
    logprobs: Optional[CompletionLogProbs] = None
634
635
    finish_reason: Optional[str] = None
    stop_reason: Optional[Union[int, str]] = Field(
636
637
638
639
640
641
        default=None,
        description=(
            "The stop string or token id that caused the completion "
            "to stop, None if the completion finished for some other reason "
            "including encountering the EOS token"),
    )
642
    prompt_logprobs: Optional[List[Optional[Dict[int, Logprob]]]] = None
Zhuohan Li's avatar
Zhuohan Li committed
643
644


645
class CompletionResponse(OpenAIBaseModel):
Zhuohan Li's avatar
Zhuohan Li committed
646
647
648
649
650
651
652
653
    id: str = Field(default_factory=lambda: f"cmpl-{random_uuid()}")
    object: str = "text_completion"
    created: int = Field(default_factory=lambda: int(time.time()))
    model: str
    choices: List[CompletionResponseChoice]
    usage: UsageInfo


654
class CompletionResponseStreamChoice(OpenAIBaseModel):
Zhuohan Li's avatar
Zhuohan Li committed
655
656
    index: int
    text: str
657
    logprobs: Optional[CompletionLogProbs] = None
658
659
    finish_reason: Optional[str] = None
    stop_reason: Optional[Union[int, str]] = Field(
660
661
662
663
664
665
        default=None,
        description=(
            "The stop string or token id that caused the completion "
            "to stop, None if the completion finished for some other reason "
            "including encountering the EOS token"),
    )
Zhuohan Li's avatar
Zhuohan Li committed
666
667


668
class CompletionStreamResponse(OpenAIBaseModel):
Zhuohan Li's avatar
Zhuohan Li committed
669
670
671
672
673
    id: str = Field(default_factory=lambda: f"cmpl-{random_uuid()}")
    object: str = "text_completion"
    created: int = Field(default_factory=lambda: int(time.time()))
    model: str
    choices: List[CompletionResponseStreamChoice]
674
    usage: Optional[UsageInfo] = Field(default=None)
675
676


677
class EmbeddingResponseData(OpenAIBaseModel):
678
679
    index: int
    object: str = "embedding"
680
    embedding: Union[List[float], str]
681
682


683
class EmbeddingResponse(OpenAIBaseModel):
684
685
686
687
688
689
690
691
    id: str = Field(default_factory=lambda: f"cmpl-{random_uuid()}")
    object: str = "list"
    created: int = Field(default_factory=lambda: int(time.time()))
    model: str
    data: List[EmbeddingResponseData]
    usage: UsageInfo


692
693
694
695
696
697
698
699
700
701
702
class FunctionCall(OpenAIBaseModel):
    name: str
    arguments: str


class ToolCall(OpenAIBaseModel):
    id: str = Field(default_factory=lambda: f"chatcmpl-tool-{random_uuid()}")
    type: Literal["function"] = "function"
    function: FunctionCall


703
704
705
706
707
708
709
710
711
712
713
714
715
716
717
718
719
720
721
722
723
724
725
726
727
class DeltaFunctionCall(BaseModel):
    name: Optional[str] = None
    arguments: Optional[str] = None


# a tool call delta where everything is optional
class DeltaToolCall(OpenAIBaseModel):
    id: str = Field(default_factory=lambda: f"chatcmpl-tool-{random_uuid()}")
    type: Literal["function"] = "function"
    index: int
    function: Optional[DeltaFunctionCall] = None


class ExtractedToolCallInformation(BaseModel):
    # indicate if tools were called
    tools_called: bool

    # extracted tool calls
    tool_calls: List[ToolCall]

    # content - per OpenAI spec, content AND tool calls can be returned rarely
    # But some models will do this intentionally
    content: Optional[str] = None


728
class ChatMessage(OpenAIBaseModel):
729
    role: str
730
    content: Optional[str] = None
731
    tool_calls: List[ToolCall] = Field(default_factory=list)
732
733


734
735
736
737
738
739
740
741
742
743
744
745
746
747
class ChatCompletionLogProb(OpenAIBaseModel):
    token: str
    logprob: float = -9999.0
    bytes: Optional[List[int]] = None


class ChatCompletionLogProbsContent(ChatCompletionLogProb):
    top_logprobs: List[ChatCompletionLogProb] = Field(default_factory=list)


class ChatCompletionLogProbs(OpenAIBaseModel):
    content: Optional[List[ChatCompletionLogProbsContent]] = None


748
class ChatCompletionResponseChoice(OpenAIBaseModel):
749
750
    index: int
    message: ChatMessage
751
    logprobs: Optional[ChatCompletionLogProbs] = None
752
753
754
    # per OpenAI spec this is the default
    finish_reason: Optional[str] = "stop"
    # not part of the OpenAI spec but included in vLLM for legacy reasons
755
    stop_reason: Optional[Union[int, str]] = None
756
757


758
class ChatCompletionResponse(OpenAIBaseModel):
759
    id: str = Field(default_factory=lambda: f"chatcmpl-{random_uuid()}")
760
    object: Literal["chat.completion"] = "chat.completion"
761
762
763
764
    created: int = Field(default_factory=lambda: int(time.time()))
    model: str
    choices: List[ChatCompletionResponseChoice]
    usage: UsageInfo
765
    prompt_logprobs: Optional[List[Optional[Dict[int, Logprob]]]] = None
766
767


768
class DeltaMessage(OpenAIBaseModel):
769
770
    role: Optional[str] = None
    content: Optional[str] = None
771
    tool_calls: List[DeltaToolCall] = Field(default_factory=list)
772
773


774
class ChatCompletionResponseStreamChoice(OpenAIBaseModel):
775
776
    index: int
    delta: DeltaMessage
777
    logprobs: Optional[ChatCompletionLogProbs] = None
778
    finish_reason: Optional[str] = None
779
    stop_reason: Optional[Union[int, str]] = None
780
781


782
class ChatCompletionStreamResponse(OpenAIBaseModel):
783
    id: str = Field(default_factory=lambda: f"chatcmpl-{random_uuid()}")
784
    object: Literal["chat.completion.chunk"] = "chat.completion.chunk"
785
786
787
    created: int = Field(default_factory=lambda: int(time.time()))
    model: str
    choices: List[ChatCompletionResponseStreamChoice]
788
    usage: Optional[UsageInfo] = Field(default=None)
789
790
791
792
793
794
795
796
797
798
799
800
801
802
803
804
805
806
807
808
809


class BatchRequestInput(OpenAIBaseModel):
    """
    The per-line object of the batch input file.

    NOTE: Currently only the `/v1/chat/completions` endpoint is supported.
    """

    # A developer-provided per-request id that will be used to match outputs to
    # inputs. Must be unique for each request in a batch.
    custom_id: str

    # The HTTP method to be used for the request. Currently only POST is
    # supported.
    method: str

    # The OpenAI API relative URL to be used for the request. Currently
    # /v1/chat/completions is supported.
    url: str

810
    # The parameters of the request.
811
    body: Union[ChatCompletionRequest, EmbeddingRequest]
812
813


814
815
816
817
818
819
820
821
class BatchResponseData(OpenAIBaseModel):
    # HTTP status code of the response.
    status_code: int = 200

    # An unique identifier for the API request.
    request_id: str

    # The body of the response.
822
    body: Optional[Union[ChatCompletionResponse, EmbeddingResponse]] = None
823
824


825
826
827
828
829
830
831
832
833
834
835
class BatchRequestOutput(OpenAIBaseModel):
    """
    The per-line object of the batch output and error files
    """

    id: str

    # A developer-provided per-request id that will be used to match outputs to
    # inputs.
    custom_id: str

836
    response: Optional[BatchResponseData]
837
838
839
840

    # For requests that failed with a non-HTTP error, this will contain more
    # information on the cause of the failure.
    error: Optional[Any]
841
842


843
844
845
846
847
848
849
850
851
852
853
class TokenizeCompletionRequest(OpenAIBaseModel):
    model: str
    prompt: str

    add_special_tokens: bool = Field(default=True)


class TokenizeChatRequest(OpenAIBaseModel):
    model: str
    messages: List[ChatCompletionMessageParam]

854
855
    add_generation_prompt: bool = Field(default=True)
    add_special_tokens: bool = Field(default=False)
856
857
858


TokenizeRequest = Union[TokenizeCompletionRequest, TokenizeChatRequest]
859
860
861
862
863


class TokenizeResponse(OpenAIBaseModel):
    count: int
    max_model_len: int
864
    tokens: List[int]
865
866
867
868
869
870
871
872
873


class DetokenizeRequest(OpenAIBaseModel):
    model: str
    tokens: List[int]


class DetokenizeResponse(OpenAIBaseModel):
    prompt: str
874
875
876
877
878
879
880
881
882
883


class LoadLoraAdapterRequest(BaseModel):
    lora_name: str
    lora_path: str


class UnloadLoraAdapterRequest(BaseModel):
    lora_name: str
    lora_int_id: Optional[int] = Field(default=None)