Skip to content

vllm.entrypoints.openai.parser.responses_parser

logger module-attribute 

logger = getLogger(__name__)

ResponsesParser

Incremental parser over completion tokens with reasoning support.

Source code in vllm/entrypoints/openai/parser/responses_parser.py 
22
23
24
25
26
27
28
29
30
31
32
33
34
35
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
71
72
73
74
75
76
77
78
79
80
class ResponsesParser:
    """Incremental parser over completion tokens with reasoning support."""

    def __init__(
        self,
        *,
        tokenizer: AnyTokenizer,
        reasoning_parser_cls: Callable[[AnyTokenizer], ReasoningParser],
        response_messages: list[ResponseInputOutputItem],
        request: ResponsesRequest,
    ):
        self.response_messages: list[ResponseInputOutputItem] = (
            # TODO: initial messages may not be properly typed
            response_messages
        )
        self.num_init_messages = len(response_messages)
        self.tokenizer = tokenizer
        self.request = request

        self.reasoning_parser_instance = reasoning_parser_cls(tokenizer)

    def process(self, output: CompletionOutput) -> "ResponsesParser":
        reasoning_content, content = self.reasoning_parser_instance.extract_reasoning(
            output.text, request=self.request
        )
        if reasoning_content:
            self.response_messages.append(
                ResponseReasoningItem(
                    type="reasoning",
                    id=f"rs_{random_uuid()}",
                    summary=[],
                    content=[
                        Content(
                            type="reasoning_text",
                            text=reasoning_content,
                        )
                    ],
                )
            )

        if content:
            self.response_messages.append(
                ResponseOutputMessage(
                    type="message",
                    id=f"msg_{random_uuid()}",
                    status="completed",
                    role="assistant",
                    content=[
                        ResponseOutputText(
                            annotations=[],  # TODO
                            type="output_text",
                            text=content,
                            logprobs=None,  # TODO
                        )
                    ],
                )
            )

        return self

num_init_messages instance-attribute 

num_init_messages = len(response_messages)

reasoning_parser_instance instance-attribute 

reasoning_parser_instance = reasoning_parser_cls(tokenizer)

request instance-attribute 

request = request

response_messages instance-attribute 

response_messages: list[ResponseInputOutputItem] = (
    response_messages
)

tokenizer instance-attribute 

tokenizer = tokenizer

__init__ 

__init__(
    *,
    tokenizer: AnyTokenizer,
    reasoning_parser_cls: Callable[
        [AnyTokenizer], ReasoningParser
    ],
    response_messages: list[ResponseInputOutputItem],
    request: ResponsesRequest,
)
Source code in vllm/entrypoints/openai/parser/responses_parser.py 
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
def __init__(
    self,
    *,
    tokenizer: AnyTokenizer,
    reasoning_parser_cls: Callable[[AnyTokenizer], ReasoningParser],
    response_messages: list[ResponseInputOutputItem],
    request: ResponsesRequest,
):
    self.response_messages: list[ResponseInputOutputItem] = (
        # TODO: initial messages may not be properly typed
        response_messages
    )
    self.num_init_messages = len(response_messages)
    self.tokenizer = tokenizer
    self.request = request

    self.reasoning_parser_instance = reasoning_parser_cls(tokenizer)

process 

process(output: CompletionOutput) -> ResponsesParser
Source code in vllm/entrypoints/openai/parser/responses_parser.py 
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
71
72
73
74
75
76
77
78
79
80
def process(self, output: CompletionOutput) -> "ResponsesParser":
    reasoning_content, content = self.reasoning_parser_instance.extract_reasoning(
        output.text, request=self.request
    )
    if reasoning_content:
        self.response_messages.append(
            ResponseReasoningItem(
                type="reasoning",
                id=f"rs_{random_uuid()}",
                summary=[],
                content=[
                    Content(
                        type="reasoning_text",
                        text=reasoning_content,
                    )
                ],
            )
        )

    if content:
        self.response_messages.append(
            ResponseOutputMessage(
                type="message",
                id=f"msg_{random_uuid()}",
                status="completed",
                role="assistant",
                content=[
                    ResponseOutputText(
                        annotations=[],  # TODO
                        type="output_text",
                        text=content,
                        logprobs=None,  # TODO
                    )
                ],
            )
        )

    return self

get_responses_parser_for_simple_context 

get_responses_parser_for_simple_context(
    *,
    tokenizer: AnyTokenizer,
    reasoning_parser_cls: Callable[
        [AnyTokenizer], ReasoningParser
    ],
    response_messages: list[ResponseInputOutputItem],
    request: ResponsesRequest,
) -> ResponsesParser

Factory function to create a ResponsesParser with optional reasoning parser.

Returns:

Type Description
ResponsesParser

ResponsesParser instance configured with the provided parser
Source code in vllm/entrypoints/openai/parser/responses_parser.py 
 83
 84
 85
 86
 87
 88
 89
 90
 91
 92
 93
 94
 95
 96
 97
 98
 99
100
101
def get_responses_parser_for_simple_context(
    *,
    tokenizer: AnyTokenizer,
    reasoning_parser_cls: Callable[[AnyTokenizer], ReasoningParser],
    response_messages: list[ResponseInputOutputItem],
    request: ResponsesRequest,
) -> ResponsesParser:
    """Factory function to create a ResponsesParser with
    optional reasoning parser.

    Returns:
        ResponsesParser instance configured with the provided parser
    """
    return ResponsesParser(
        tokenizer=tokenizer,
        reasoning_parser_cls=reasoning_parser_cls,
        response_messages=response_messages,
        request=request,
    )