# -*- coding: utf-8 -*-
# Copyright (c) Alibaba, Inc. and its affiliates.
import copy
# pylint: disable=R1702,too-many-branches,too-many-return-statements
# pylint: disable=too-many-statements
def merge_single_response( # noqa: E501
parsed_response,
accumulated_data,
n=1,
):
"""Merge a single response chunk with accumulated data.
Args:
parsed_response: The response chunk to merge
accumulated_data: Dictionary storing accumulated data for each choice
n: Number of expected choices (default 1)
Returns:
bool or list: True if this response should be yielded normally,
False if filtered, or a list of responses for n>1 with
non-stop finish reasons
"""
# Check if all choices have been sent (for n > 1 case)
if n > 1 and accumulated_data:
all_sent = all(
data.get("all_choices_sent", False)
for data in accumulated_data.values()
if isinstance(data, dict) and "all_choices_sent" in data
)
if all_sent:
return False
# Track usage for each choice index when n > 1
# Each streaming packet contains usage info for one specific choice
if (
n > 1
and parsed_response.usage
and parsed_response.output
and parsed_response.output.choices
and len(parsed_response.output.choices) > 0
):
if "usage_by_index" not in accumulated_data:
accumulated_data["usage_by_index"] = {}
# Get the choice index from the first (and typically only) choice in this packet # noqa: E501 # pylint: disable=line-too-long
try:
first_choice = parsed_response.output.choices[0]
choice_idx = (
first_choice.index
if hasattr(
first_choice,
"index",
)
and "index" in first_choice
else 0
)
# Store only output_tokens for this choice index
if "output_tokens" in parsed_response.usage:
accumulated_data["usage_by_index"][choice_idx] = dict(
parsed_response.usage,
)
except (KeyError, AttributeError, IndexError):
pass
# Handle output.text accumulation when choices is null
if (
parsed_response.output
and hasattr(parsed_response.output, "text")
and (
not parsed_response.output.choices
or parsed_response.output.choices is None
)
):
choice_idx = 0
if choice_idx not in accumulated_data:
accumulated_data[choice_idx] = {
"content": "",
"reasoning_content": "",
"tool_calls": [],
"logprobs": {"content": []},
"finished": False,
"finish_reason": None,
"all_choices_sent": False,
"role": None,
}
# Accumulate text if not empty
if parsed_response.output.text:
accumulated_data[choice_idx][
"content"
] += parsed_response.output.text
# Always set accumulated content back to response
parsed_response.output.text = accumulated_data[choice_idx]["content"]
return True
# Process each choice in the choices array
if parsed_response.output and parsed_response.output.choices:
choices = parsed_response.output.choices
# Filter out empty choices array
if not choices:
return False
for choice_enum_idx, choice in enumerate(choices):
# Use choice.index if available, otherwise use enumerate index
try:
choice_idx = (
choice.index
if hasattr(choice, "index") and "index" in choice
else choice_enum_idx
)
except (KeyError, AttributeError):
choice_idx = choice_enum_idx
# Initialize accumulated data for this choice if not exists
if choice_idx not in accumulated_data:
accumulated_data[choice_idx] = {
"content": "",
"reasoning_content": "",
"tool_calls": [],
"logprobs": {"content": []},
"finished": False,
"finish_reason": None,
"all_choices_sent": False,
"role": None,
}
# Handle message field - create if null
if not choice.message:
# Create message object with accumulated data
choice.message = {
"role": accumulated_data[choice_idx]["role"]
if accumulated_data[choice_idx]["role"]
else "assistant",
"content": accumulated_data[choice_idx]["content"],
}
if accumulated_data[choice_idx]["reasoning_content"]:
choice.message["reasoning_content"] = accumulated_data[
choice_idx
]["reasoning_content"]
if accumulated_data[choice_idx]["tool_calls"]:
choice.message["tool_calls"] = accumulated_data[
choice_idx
]["tool_calls"]
else:
# Save role if present
if hasattr(choice.message, "role") and choice.message.role:
accumulated_data[choice_idx]["role"] = choice.message.role
# Handle content accumulation
if "content" in choice.message:
current_content = choice.message.content
if current_content:
# Check if content is multimodal format
if isinstance(current_content, list):
# Handle multimodal content (array format)
# Initialize accumulated content as array if not already # noqa: E501
if not isinstance(
accumulated_data[choice_idx]["content"],
list,
):
accumulated_data[choice_idx]["content"] = []
# Ensure accumulated content list has enough elements # noqa: E501
while len(
accumulated_data[choice_idx]["content"],
) < len(current_content):
accumulated_data[choice_idx]["content"].append(
{"text": ""},
)
# Merge each content element
for content_idx, content_item in enumerate(
current_content,
):
if (
isinstance(content_item, dict)
and "text" in content_item
):
if content_item["text"]:
# Accumulate text content
accumulated_data[choice_idx][
"content"
][content_idx]["text"] += content_item[
"text"
]
# Update the current response with accumulated content # noqa: E501
for content_idx in range(
len(accumulated_data[choice_idx]["content"]),
):
if content_idx < len(choice.message.content):
choice.message.content[content_idx][
"text"
] = accumulated_data[choice_idx][
"content"
][
content_idx
][
"text"
]
else:
# Handle regular content (string format)
# Initialize accumulated content as string
if isinstance(
accumulated_data[choice_idx]["content"],
list,
):
accumulated_data[choice_idx]["content"] = ""
# Accumulate content if not empty
accumulated_data[choice_idx][
"content"
] += current_content
# Always set accumulated content back to response
if not isinstance(
accumulated_data[choice_idx]["content"],
list,
):
choice.message.content = accumulated_data[choice_idx][
"content"
]
else:
# For multimodal content, ensure message.content
# exists
if not isinstance(choice.message.content, list):
choice.message.content = accumulated_data[
choice_idx
]["content"]
# Handle reasoning_content accumulation
if "reasoning_content" in choice.message:
current_reasoning_content = (
choice.message.reasoning_content
)
if current_reasoning_content:
accumulated_data[choice_idx][
"reasoning_content"
] += current_reasoning_content
# Always set the accumulated reasoning_content back if we
# have any, even if current response doesn't have it
if accumulated_data[choice_idx]["reasoning_content"]:
choice.message.reasoning_content = accumulated_data[
choice_idx
]["reasoning_content"]
# Handle tool_calls accumulation
if (
"tool_calls" in choice.message
and choice.message.tool_calls
):
current_tool_calls = choice.message.tool_calls
# For each current tool call, accumulate its arguments
for current_call in current_tool_calls:
if (
isinstance(current_call, dict)
and "index" in current_call
):
idx = current_call["index"]
# Find existing accumulated call with same index
existing_call = None
for acc_call in accumulated_data[choice_idx][
"tool_calls"
]:
if (
isinstance(acc_call, dict)
and acc_call.get("index") == idx
):
existing_call = acc_call
break
if existing_call:
# Accumulate function fields from current call
if (
"function" in current_call
and current_call["function"]
):
if "function" not in existing_call:
existing_call["function"] = {}
# Accumulate function.name
if "name" in current_call["function"]:
if (
"name"
not in existing_call["function"]
):
existing_call["function"][
"name"
] = ""
existing_call["function"][
"name"
] += current_call["function"]["name"]
# Accumulate function.arguments
if "arguments" in current_call["function"]:
if (
"arguments"
not in existing_call["function"]
):
existing_call["function"][
"arguments"
] = ""
existing_call["function"][
"arguments"
] += current_call["function"][
"arguments"
]
# Update other fields with latest values
existing_call.update(
{
k: v
for k, v in current_call.items()
if k != "function" and v
},
)
if (
"function" in current_call
and current_call["function"]
):
existing_call["function"].update(
{
k: v
for k, v in current_call[
"function"
].items()
if k not in ["arguments", "name"]
and v
},
)
else:
# Add new tool call
accumulated_data[choice_idx][
"tool_calls"
].append(dict(current_call))
# Update choice with accumulated tool_calls
choice.message.tool_calls = accumulated_data[choice_idx][
"tool_calls"
]
elif accumulated_data[choice_idx]["tool_calls"]:
# If current response has no tool_calls but we have
# accumulated tool_calls, restore them
choice.message.tool_calls = accumulated_data[choice_idx][
"tool_calls"
]
# Restore role if we have it
if accumulated_data[choice_idx]["role"] and (
not hasattr(choice.message, "role")
or not choice.message.role
):
choice.message.role = accumulated_data[choice_idx]["role"]
# Handle logprobs accumulation (only if logprobs exists)
try:
if (
"logprobs" in choice
and choice.logprobs
and isinstance(choice.logprobs, dict)
and "content" in choice.logprobs
):
current_logprobs_content = choice.logprobs["content"]
if current_logprobs_content and isinstance(
current_logprobs_content,
list,
):
# Initialize logprobs content if not exists
if "logprobs" not in accumulated_data[choice_idx]:
accumulated_data[choice_idx]["logprobs"] = {
"content": [],
}
elif (
"content"
not in accumulated_data[choice_idx]["logprobs"]
):
accumulated_data[choice_idx]["logprobs"][
"content"
] = []
# Extend the accumulated logprobs content array
accumulated_data[choice_idx]["logprobs"][
"content"
].extend(current_logprobs_content)
except (KeyError, AttributeError, TypeError):
# logprobs field might not exist or be in unexpected format, safely skip # noqa: E501 # pylint: disable=line-too-long
pass
# Always set accumulated logprobs if we have any
if (
accumulated_data[choice_idx]["logprobs"]["content"]
and hasattr(choice, "logprobs")
and choice.logprobs
):
choice.logprobs["content"] = accumulated_data[choice_idx][
"logprobs"
]["content"]
# Handle finish_reason for n > 1 case
if (
n > 1
and hasattr(choice, "finish_reason")
and choice.finish_reason
and choice.finish_reason != "null"
):
accumulated_data[choice_idx][
"finish_reason"
] = choice.finish_reason
accumulated_data[choice_idx]["finished"] = True
# Handle n > 1 case: different strategies for different finish_reason
if n > 1:
# Count finished choices
finished_count = sum(
1
for data in accumulated_data.values()
if isinstance(data, dict) and data.get("finished", False)
)
# Find all finished choices in current packet
finished_choices_in_packet = []
for choice in choices:
if (
hasattr(choice, "finish_reason")
and choice.finish_reason
and choice.finish_reason != "null"
):
choice_idx = (
choice.index
if hasattr(choice, "index") and "index" in choice
else 0
)
finish_reason = choice.finish_reason
finished_choices_in_packet.append(
(choice_idx, finish_reason, choice),
)
# No finish_reason in current packet: return as is
if not finished_choices_in_packet:
return True
# Get finish_reason type from first finished choice
first_finish_reason = finished_choices_in_packet[0][1]
# For stop: wait all choices, then merge into one result
if first_finish_reason == "stop":
if finished_count < n:
# Hide finish_reason until all finished
for choice in choices:
if (
hasattr(choice, "finish_reason")
and choice.finish_reason
and choice.finish_reason != "null"
):
choice.finish_reason = "null"
else:
# All finished: merge all choices into one result
for data in accumulated_data.values():
if (
isinstance(data, dict)
and "all_choices_sent" in data
):
data["all_choices_sent"] = True
# Return final result with all choices
all_choices = []
# Sort by choice_idx to ensure correct order
sorted_items = sorted(
[
(idx, data)
for idx, data in accumulated_data.items()
if isinstance(data, dict) and "finished" in data
],
key=lambda x: x[0],
)
for choice_idx, data in sorted_items:
# Create a new choice object
final_choice_dict = {
"index": choice_idx,
"finish_reason": data["finish_reason"],
}
# Create message
message_dict = {
"role": data["role"]
if data["role"]
else "assistant",
}
if data["content"]:
message_dict["content"] = (
data["content"]
if isinstance(data["content"], str)
else data["content"]
)
if data["reasoning_content"]:
message_dict["reasoning_content"] = data[
"reasoning_content"
]
if data["tool_calls"]:
message_dict["tool_calls"] = data["tool_calls"]
final_choice_dict["message"] = message_dict
# Add logprobs if present
if data["logprobs"]["content"]:
final_choice_dict["logprobs"] = {
"content": data["logprobs"]["content"],
}
all_choices.append(final_choice_dict)
# Update output choices with all accumulated choices
parsed_response.output.choices = all_choices
# Aggregate usage from all choice indices
if (
"usage_by_index" in accumulated_data
and accumulated_data["usage_by_index"]
):
aggregated_usage = {}
usage_by_idx = accumulated_data["usage_by_index"]
# Sum output_tokens and recalculate total_tokens
total_output_tokens = 0
input_tokens = None
prompt_tokens_details = None
for idx, usage in usage_by_idx.items():
if "output_tokens" in usage:
total_output_tokens += usage["output_tokens"]
# input_tokens should be the same for all indices
if (
input_tokens is None
and "input_tokens" in usage
):
input_tokens = usage["input_tokens"]
# Keep prompt_tokens_details from any index
# (should be same)
if (
prompt_tokens_details is None
and "prompt_tokens_details" in usage
):
prompt_tokens_details = usage[
"prompt_tokens_details"
]
# Build aggregated usage
if input_tokens is not None:
aggregated_usage["input_tokens"] = input_tokens
aggregated_usage["output_tokens"] = total_output_tokens
if input_tokens is not None:
aggregated_usage["total_tokens"] = (
input_tokens + total_output_tokens
)
if prompt_tokens_details is not None:
aggregated_usage[
"prompt_tokens_details"
] = prompt_tokens_details
# Update response usage with aggregated values
parsed_response.usage = aggregated_usage
else:
# For non-stop (e.g., tool_calls): output each choice separately # noqa: E501
responses_to_yield = []
for (
choice_idx,
finish_reason,
choice,
) in finished_choices_in_packet:
current_data = accumulated_data.get(choice_idx)
if current_data is None or current_data.get(
"all_choices_sent",
False,
):
continue
current_data["all_choices_sent"] = True
# Create a new response for this choice
if responses_to_yield:
# Clone the response for additional choices
new_response = copy.deepcopy(parsed_response)
else:
# Use the original response for the first choice
new_response = parsed_response
# Deep copy choice to avoid modifying accumulated_data
choice_copy = copy.deepcopy(choice)
# Set only this choice in the response
new_response.output.choices = [choice_copy]
# Update usage with this choice's output tokens
if (
new_response.usage
and "usage_by_index" in accumulated_data
and choice_idx in accumulated_data["usage_by_index"]
):
current_usage = accumulated_data["usage_by_index"][
choice_idx
]
if "output_tokens" in current_usage:
new_response.usage[
"output_tokens"
] = current_usage["output_tokens"]
if "input_tokens" in current_usage:
new_response.usage["total_tokens"] = (
current_usage["input_tokens"]
+ current_usage["output_tokens"]
)
responses_to_yield.append(new_response)
# Return list of responses if we have any
if responses_to_yield:
return responses_to_yield
else:
return False
return True
# pylint: disable=R1702,too-many-branches,too-many-statements
def merge_multimodal_single_response( # noqa: E501
parsed_response,
accumulated_data,
n=1,
):
"""Merge a single response chunk with accumulated data.
Args:
parsed_response: The response chunk to merge
accumulated_data: Dictionary storing accumulated data for each choice
n: Number of expected choices (default 1)
Returns:
bool: True if this response should be yielded, False if filtered
"""
# Check if all choices have been sent (for n > 1 case)
if n > 1 and accumulated_data:
all_sent = any(
data.get("all_choices_sent", False)
for data in accumulated_data.values()
)
if all_sent:
return False
# Track usage for each choice index when n > 1
# Each streaming packet contains usage info for one specific choice
if (
n > 1
and parsed_response.usage
and parsed_response.output
and parsed_response.output.choices
and len(parsed_response.output.choices) > 0
):
if "usage_by_index" not in accumulated_data:
accumulated_data["usage_by_index"] = {}
# Get the choice index from the first (and typically only) choice in this packet # noqa: E501 # pylint: disable=line-too-long
try:
first_choice = parsed_response.output.choices[0]
choice_idx = (
first_choice.index
if hasattr(
first_choice,
"index",
)
and "index" in first_choice
else 0
)
# Store only output_tokens for this choice index
if "output_tokens" in parsed_response.usage:
accumulated_data["usage_by_index"][choice_idx] = dict(
parsed_response.usage,
)
except (KeyError, AttributeError, IndexError):
pass
# Handle output.text accumulation when choices is null
if (
parsed_response.output
and hasattr(parsed_response.output, "text")
and (
not parsed_response.output.choices
or parsed_response.output.choices is None
)
):
choice_idx = 0
if choice_idx not in accumulated_data:
accumulated_data[choice_idx] = {
"content": "",
"reasoning_content": "",
"tool_calls": [],
"logprobs": {"content": []},
"finished": False,
"finish_reason": None,
"all_choices_sent": False,
"role": None,
}
# Accumulate text if not empty
if parsed_response.output.text:
accumulated_data[choice_idx][
"content"
] += parsed_response.output.text
# Always set accumulated content back to response
parsed_response.output.text = accumulated_data[choice_idx]["content"]
return True
# Process each choice in the choices array
if parsed_response.output and parsed_response.output.choices:
choices = parsed_response.output.choices
# Filter out empty choices array
if not choices:
return False
for choice_enum_idx, choice in enumerate(choices):
# Use choice.index if available, otherwise use enumerate index
try:
choice_idx = (
choice.index
if hasattr(choice, "index") and "index" in choice
else choice_enum_idx
)
except (KeyError, AttributeError):
choice_idx = choice_enum_idx
# Initialize accumulated data for this choice if not exists
if choice_idx not in accumulated_data:
accumulated_data[choice_idx] = {
"content": "",
"reasoning_content": "",
"tool_calls": [],
"logprobs": {"content": []},
"finished": False,
"finish_reason": None,
"all_choices_sent": False,
"role": None,
}
# Handle message field - create if null
if not choice.message:
# Create message object with accumulated data
choice.message = {
"role": accumulated_data[choice_idx]["role"]
if accumulated_data[choice_idx]["role"]
else "assistant",
"content": accumulated_data[choice_idx]["content"],
}
if accumulated_data[choice_idx]["reasoning_content"]:
choice.message["reasoning_content"] = accumulated_data[
choice_idx
]["reasoning_content"]
if accumulated_data[choice_idx]["tool_calls"]:
choice.message["tool_calls"] = accumulated_data[
choice_idx
]["tool_calls"]
else:
# Save role if present
if hasattr(choice.message, "role") and choice.message.role:
accumulated_data[choice_idx]["role"] = choice.message.role
# Handle content accumulation
if "content" in choice.message:
current_content = choice.message.content
# Check if content is multimodal format
if isinstance(current_content, list):
# Handle multimodal content (array format)
# Initialize accumulated content as array if not already # noqa: E501
if not isinstance(
accumulated_data[choice_idx]["content"],
list,
):
accumulated_data[choice_idx]["content"] = []
# Only process if current_content is not empty
if current_content:
# Ensure accumulated content list has enough elements # noqa: E501
while len(
accumulated_data[choice_idx]["content"],
) < len(current_content):
accumulated_data[choice_idx]["content"].append(
{"text": ""},
)
# Merge each content element
for content_idx, content_item in enumerate(
current_content,
):
if (
isinstance(content_item, dict)
and "text" in content_item
):
if content_item["text"]:
# Accumulate text content
accumulated_data[choice_idx][
"content"
][content_idx]["text"] += content_item[
"text"
]
# Always set accumulated content back to response
choice.message.content = accumulated_data[choice_idx][
"content"
]
elif current_content:
# Handle regular content (string format)
# Initialize accumulated content as string
if isinstance(
accumulated_data[choice_idx]["content"],
list,
):
accumulated_data[choice_idx]["content"] = ""
# Accumulate content if not empty
accumulated_data[choice_idx][
"content"
] += current_content
# Set accumulated content back to response
choice.message.content = accumulated_data[choice_idx][
"content"
]
elif (
not current_content
and accumulated_data[choice_idx]["content"]
):
# Current content is empty but we have accumulated content, restore it # noqa: E501 # pylint: disable=line-too-long
choice.message.content = accumulated_data[choice_idx][
"content"
]
# Handle reasoning_content accumulation
if "reasoning_content" in choice.message:
current_reasoning_content = (
choice.message.reasoning_content
)
if current_reasoning_content:
accumulated_data[choice_idx][
"reasoning_content"
] += current_reasoning_content
# Always set the accumulated reasoning_content back if we
# have any, even if current response doesn't have it
if accumulated_data[choice_idx]["reasoning_content"]:
choice.message.reasoning_content = accumulated_data[
choice_idx
]["reasoning_content"]
# Handle tool_calls accumulation
if (
"tool_calls" in choice.message
and choice.message.tool_calls
):
current_tool_calls = choice.message.tool_calls
# For each current tool call, accumulate its arguments
for current_call in current_tool_calls:
if (
isinstance(current_call, dict)
and "index" in current_call
):
idx = current_call["index"]
# Find existing accumulated call with same index
existing_call = None
for acc_call in accumulated_data[choice_idx][
"tool_calls"
]:
if (
isinstance(acc_call, dict)
and acc_call.get("index") == idx
):
existing_call = acc_call
break
if existing_call:
# Accumulate function fields from current call
if (
"function" in current_call
and current_call["function"]
):
if "function" not in existing_call:
existing_call["function"] = {}
# Accumulate function.name
if "name" in current_call["function"]:
if (
"name"
not in existing_call["function"]
):
existing_call["function"][
"name"
] = ""
existing_call["function"][
"name"
] += current_call["function"]["name"]
# Accumulate function.arguments
if "arguments" in current_call["function"]:
if (
"arguments"
not in existing_call["function"]
):
existing_call["function"][
"arguments"
] = ""
existing_call["function"][
"arguments"
] += current_call["function"][
"arguments"
]
# Update other fields with latest values
existing_call.update(
{
k: v
for k, v in current_call.items()
if k != "function" and v
},
)
if (
"function" in current_call
and current_call["function"]
):
existing_call["function"].update(
{
k: v
for k, v in current_call[
"function"
].items()
if k not in ["arguments", "name"]
and v
},
)
else:
# Add new tool call
accumulated_data[choice_idx][
"tool_calls"
].append(dict(current_call))
# Update choice with accumulated tool_calls
choice.message.tool_calls = accumulated_data[choice_idx][
"tool_calls"
]
elif accumulated_data[choice_idx]["tool_calls"]:
# If current response has no tool_calls but we have accumulated tool_calls, restore them # noqa: E501 # pylint: disable=line-too-long
choice.message.tool_calls = accumulated_data[choice_idx][
"tool_calls"
]
# Restore role if we have it
if accumulated_data[choice_idx]["role"] and (
not hasattr(choice.message, "role")
or not choice.message.role
):
choice.message.role = accumulated_data[choice_idx]["role"]
# Handle logprobs accumulation (only if logprobs exists)
try:
if (
"logprobs" in choice
and choice.logprobs
and isinstance(choice.logprobs, dict)
and "content" in choice.logprobs
):
current_logprobs_content = choice.logprobs["content"]
if current_logprobs_content and isinstance(
current_logprobs_content,
list,
):
# Initialize logprobs content if not exists
if "logprobs" not in accumulated_data[choice_idx]:
accumulated_data[choice_idx]["logprobs"] = {
"content": [],
}
elif (
"content"
not in accumulated_data[choice_idx]["logprobs"]
):
accumulated_data[choice_idx]["logprobs"][
"content"
] = []
# Extend the accumulated logprobs content array
accumulated_data[choice_idx]["logprobs"][
"content"
].extend(current_logprobs_content)
except (KeyError, AttributeError, TypeError):
# logprobs field might not exist or be in unexpected format, safely skip # noqa: E501 # pylint: disable=line-too-long
pass
# Always set accumulated logprobs if we have any
if (
accumulated_data[choice_idx]["logprobs"]["content"]
and hasattr(choice, "logprobs")
and choice.logprobs
):
choice.logprobs["content"] = accumulated_data[choice_idx][
"logprobs"
]["content"]
# Handle finish_reason for n > 1 case
if (
n > 1
and hasattr(choice, "finish_reason")
and choice.finish_reason
and choice.finish_reason != "null"
):
accumulated_data[choice_idx][
"finish_reason"
] = choice.finish_reason
accumulated_data[choice_idx]["finished"] = True
# Handle n > 1 case: different strategies for different
# finish_reason
if n > 1:
# Count finished choices
finished_count = sum(
1
for data in accumulated_data.values()
if isinstance(data, dict) and data.get("finished", False)
)
# Find all finished choices in current packet
finished_choices_in_packet = []
for choice in choices:
if (
hasattr(choice, "finish_reason")
and choice.finish_reason
and choice.finish_reason != "null"
):
choice_idx = (
choice.index
if hasattr(choice, "index") and "index" in choice
else 0
)
finish_reason = choice.finish_reason
finished_choices_in_packet.append(
(choice_idx, finish_reason, choice),
)
# No finish_reason in current packet: return as is
if not finished_choices_in_packet:
return True
# Get finish_reason type from first finished choice
first_finish_reason = finished_choices_in_packet[0][1]
# For stop: wait all choices, then merge into one result
if first_finish_reason == "stop":
if finished_count < n:
# Hide finish_reason until all finished
for choice in choices:
if (
hasattr(choice, "finish_reason")
and choice.finish_reason
and choice.finish_reason != "null"
):
choice.finish_reason = "null"
else:
# All finished: merge all choices into one result
for data in accumulated_data.values():
if (
isinstance(data, dict)
and "all_choices_sent" in data
):
data["all_choices_sent"] = True
# Return final result with all choices
all_choices = []
# Sort by choice_idx to ensure correct order
sorted_items = sorted(
[
(idx, data)
for idx, data in accumulated_data.items()
if isinstance(data, dict) and "finished" in data
],
key=lambda x: x[0],
)
for choice_idx, data in sorted_items:
# Create a new choice object
final_choice_dict = {
"index": choice_idx,
"finish_reason": data["finish_reason"],
}
# Create message
message_dict = {
"role": data["role"]
if data["role"]
else "assistant",
}
if data["content"]:
message_dict["content"] = (
data["content"]
if isinstance(
data["content"],
str,
)
else data["content"]
)
if data["reasoning_content"]:
message_dict["reasoning_content"] = data[
"reasoning_content"
]
if data["tool_calls"]:
message_dict["tool_calls"] = data["tool_calls"]
final_choice_dict["message"] = message_dict
# Add logprobs if present
if data["logprobs"]["content"]:
final_choice_dict["logprobs"] = {
"content": data["logprobs"]["content"],
}
all_choices.append(final_choice_dict)
# Update output choices with all accumulated choices
parsed_response.output.choices = all_choices
# Aggregate usage from all choice indices
if (
"usage_by_index" in accumulated_data
and accumulated_data["usage_by_index"]
):
aggregated_usage = {}
usage_by_idx = accumulated_data["usage_by_index"]
# Sum output_tokens and recalculate total_tokens
total_output_tokens = 0
input_tokens = None
prompt_tokens_details = None
for idx, usage in usage_by_idx.items():
if "output_tokens" in usage:
total_output_tokens += usage["output_tokens"]
# input_tokens should be the same for all indices
if (
input_tokens is None
and "input_tokens" in usage
):
input_tokens = usage["input_tokens"]
# Keep prompt_tokens_details from any index
# (should be same)
if (
prompt_tokens_details is None
and "prompt_tokens_details" in usage
):
prompt_tokens_details = usage[
"prompt_tokens_details"
]
# Build aggregated usage
if input_tokens is not None:
aggregated_usage["input_tokens"] = input_tokens
aggregated_usage["output_tokens"] = total_output_tokens
if input_tokens is not None:
aggregated_usage["total_tokens"] = (
input_tokens + total_output_tokens
)
if prompt_tokens_details is not None:
aggregated_usage[
"prompt_tokens_details"
] = prompt_tokens_details
# Update response usage with aggregated values
parsed_response.usage = aggregated_usage
else:
# For non-stop (e.g., tool_calls): output each choice
# separately
responses_to_yield = []
for (
choice_idx,
finish_reason,
choice,
) in finished_choices_in_packet:
current_data = accumulated_data.get(choice_idx)
if current_data is None or current_data.get(
"all_choices_sent",
False,
):
continue
current_data["all_choices_sent"] = True
# Create a new response for this choice
if responses_to_yield:
# Clone the response for additional choices
new_response = copy.deepcopy(parsed_response)
else:
# Use the original response for the first choice
new_response = parsed_response
# Deep copy choice to avoid modifying accumulated_data
choice_copy = copy.deepcopy(choice)
# Set only this choice in the response
new_response.output.choices = [choice_copy]
# Update usage with this choice's output tokens
if (
new_response.usage
and "usage_by_index" in accumulated_data
and choice_idx in accumulated_data["usage_by_index"]
):
current_usage = accumulated_data["usage_by_index"][
choice_idx
]
if "output_tokens" in current_usage:
new_response.usage[
"output_tokens"
] = current_usage["output_tokens"]
if "input_tokens" in current_usage:
new_response.usage["total_tokens"] = (
current_usage["input_tokens"]
+ current_usage["output_tokens"]
)
responses_to_yield.append(new_response)
# Return list of responses if we have any
if responses_to_yield:
return responses_to_yield
else:
return False
return True
# -*- coding: utf-8 -*-
# Copyright (c) Alibaba, Inc. and its affiliates.
import copy
# pylint: disable=R1702,too-many-branches,too-many-return-statements
# pylint: disable=too-many-statements
def merge_single_response( # noqa: E501
parsed_response,
accumulated_data,
n=1,
):
"""Merge a single response chunk with accumulated data.
Args:
parsed_response: The response chunk to merge
accumulated_data: Dictionary storing accumulated data for each choice
n: Number of expected choices (default 1)
Returns:
bool or list: True if this response should be yielded normally,
False if filtered, or a list of responses for n>1 with
non-stop finish reasons
"""
# Check if all choices have been sent (for n > 1 case)
if n > 1 and accumulated_data:
all_sent = all(
data.get("all_choices_sent", False)
for data in accumulated_data.values()
if isinstance(data, dict) and "all_choices_sent" in data
)
if all_sent:
return False
# Track usage for each choice index when n > 1
# Each streaming packet contains usage info for one specific choice
if (
n > 1
and parsed_response.usage
and parsed_response.output
and parsed_response.output.choices
and len(parsed_response.output.choices) > 0
):
if "usage_by_index" not in accumulated_data:
accumulated_data["usage_by_index"] = {}
# Get the choice index from the first (and typically only) choice in this packet # noqa: E501 # pylint: disable=line-too-long
try:
first_choice = parsed_response.output.choices[0]
choice_idx = (
first_choice.index
if hasattr(
first_choice,
"index",
)
and "index" in first_choice
else 0
)
# Store only output_tokens for this choice index
if "output_tokens" in parsed_response.usage:
accumulated_data["usage_by_index"][choice_idx] = dict(
parsed_response.usage,
)
except (KeyError, AttributeError, IndexError):
pass
# Handle output.text accumulation when choices is null
if (
parsed_response.output
and hasattr(parsed_response.output, "text")
and (
not parsed_response.output.choices
or parsed_response.output.choices is None
)
):
choice_idx = 0
if choice_idx not in accumulated_data:
accumulated_data[choice_idx] = {
"content": "",
"reasoning_content": "",
"tool_calls": [],
"logprobs": {"content": []},
"finished": False,
"finish_reason": None,
"all_choices_sent": False,
"role": None,
}
# Accumulate text if not empty
if parsed_response.output.text:
accumulated_data[choice_idx][
"content"
] += parsed_response.output.text
# Always set accumulated content back to response
parsed_response.output.text = accumulated_data[choice_idx]["content"]
return True
# Process each choice in the choices array
if parsed_response.output and parsed_response.output.choices:
choices = parsed_response.output.choices