Skip to content

fix: omit malformed reasoning items to prevent OpenAI 400 errors #9362

New issue

Have a question about this project? Sign up for a free GitHub account to open an issue and contact its maintainers and the community.

Sign up for GitHub

By clicking “Sign up for GitHub”, you agree to our terms of service and privacy statement. We’ll occasionally send you account related emails.

Already on GitHub? Sign in to your account

Open
pallaprolus wants to merge 8 commits into
base: main
Choose a base branch
from
+404 −80
Open

fix: omit malformed reasoning items to prevent OpenAI 400 errors #9362

Show file tree
Hide file tree
Changes from all commits
Commits
Show all changes
8 commits
Select commit Hold shift + click to select a range
617de7f
fix: omit malformed reasoning items to prevent OpenAI 400 errors
pallaprolus Dec 31, 2025
0f777ae
refactor: reduce complexity of toResponsesInput helper
pallaprolus Dec 31, 2025
cdcb2f6
fix: preserve tool call IDs even if reasoning is dropped
pallaprolus Dec 31, 2025
4760893
fix: inject placeholder for missing encrypted content instead of drop…
pallaprolus Dec 31, 2025
6ed43c4
fix(core): resolve TS error 'toolCalls does not exist on ChatMessage'
pallaprolus Dec 31, 2025
f17632e
fix: revert placeholder; omit malformed items but preserve tool calls
pallaprolus Dec 31, 2025
a70532b
ci: re-trigger checks to resolve flakes
pallaprolus Dec 31, 2025
c20d4c5
fix: skip reasoning only when assistant references it
pallaprolus Jan 7, 2026
File filter

Filter by extension

Filter by extension
Conversations
Failed to load comments.
Loading
Jump to
Jump to file
Failed to load files.
Loading
Diff view
Diff view
232 changes: 152 additions & 80 deletions core/llm/openaiTypeConverters.ts
View file
Open in desktop
Original file line number Diff line number Diff line change
Expand Up @@ -774,8 +774,139 @@ function toResponseInputContentList(
return list;
}

/** Result type for serializeThinkingMessage */
type SerializeThinkingResult =
| { type: "item"; item: ResponseInputItem }
| { type: "skip" };

/**
* Serialize a thinking message to a ResponseInputItem.
* @param msg - The thinking message to serialize
* @param nextMsgHasReference - Whether the next assistant message references this reasoning
* @returns The serialized item, a skip signal, or undefined if no details
*/
function serializeThinkingMessage(
msg: ThinkingChatMessage,
nextMsgHasReference: boolean,
): SerializeThinkingResult | undefined {
const details = msg.reasoning_details ?? [];
if (!details.length) return undefined;

let id: string | undefined;
let summaryText = "";
let encrypted: string | undefined;
let reasoningText = "";

for (const raw of details as Array<Record<string, unknown>>) {
const d = raw as {
type?: string;
id?: string;
text?: string;
encrypted_content?: string;
};
if (d.type === "reasoning_id" && d.id) id = d.id;
else if (d.type === "encrypted_content" && d.encrypted_content)
encrypted = d.encrypted_content;
else if (d.type === "summary_text" && typeof d.text === "string")
summaryText += d.text;
else if (d.type === "reasoning_text" && typeof d.text === "string")
reasoningText += d.text;
}

if (id) {
// Only skip if: no encrypted_content AND next assistant message has a responsesOutputItemId.
// The responsesOutputItemId indicates the assistant expects its paired reasoning to be present,
// so omitting reasoning without encrypted_content would cause a 400 error.
if (!encrypted && nextMsgHasReference) {
return { type: "skip" };
}

const reasoningItem: ResponseReasoningItem = {
id,
type: "reasoning",
summary: [],
} as ResponseReasoningItem;
if (summaryText) {
reasoningItem.summary = [{ type: "summary_text", text: summaryText }];
}
if (reasoningText) {
reasoningItem.content = [{ type: "reasoning_text", text: reasoningText }];
}
if (encrypted) {
reasoningItem.encrypted_content = encrypted;
}

return { type: "item", item: reasoningItem as ResponseInputItem };
}
return undefined;
}

/** Result type for serializeAssistantMessage */
type SerializeAssistantResult =
| { type: "item"; item: ResponseInputItem }
| { type: "fallback"; role: "assistant"; content: string };

/**
* Serialize an assistant message to a ResponseInputItem.
* @param msg - The assistant message to serialize
* @param stripId - Whether to strip the responsesOutputItemId (when paired reasoning was skipped)
*/
function serializeAssistantMessage(
msg: ChatMessage,
stripId: boolean,
): SerializeAssistantResult {
const text = getTextFromMessageContent(msg.content);
const originalRespId = msg.metadata?.responsesOutputItemId as
| string
| undefined;
const respId = stripId ? undefined : originalRespId;

const toolCalls = (msg as AssistantChatMessage).toolCalls as
| ToolCallDelta[]
| undefined;

if (Array.isArray(toolCalls) && toolCalls.length > 0) {
const tc = toolCalls[0];
const name = tc?.function?.name as string | undefined;
const args = tc?.function?.arguments as string | undefined;
const call_id = tc?.id as string | undefined;

// ResponseFunctionToolCall has optional 'id' field
const functionCallItem: ResponseFunctionToolCall = {
type: "function_call",
name: name || "",
arguments: typeof args === "string" ? args : "{}",
call_id: call_id || respId || "",
};
if (respId) {
functionCallItem.id = respId;
}
return { type: "item", item: functionCallItem };
} else if (respId) {
// Emit full assistant output message item with ID
const outputMessageItem: ResponseOutputMessage = {
id: respId,
role: "assistant",
type: "message",
status: "completed",
content: [
{
type: "output_text",
text: text || "",
annotations: [],
} satisfies ResponseOutputText,
],
};
return { type: "item", item: outputMessageItem };
} else {
// Fallback to EasyInput assistant message
return { type: "fallback", role: "assistant", content: text || "" };
}
}

export function toResponsesInput(messages: ChatMessage[]): ResponseInput {
const input: ResponseInput = [];
let stripNextAssistantId = false;

const pushMessage = (
role: "user" | "assistant" | "system" | "developer",
Expand Down Expand Up @@ -811,47 +942,13 @@ export function toResponsesInput(messages: ChatMessage[]): ResponseInput {
break;
}
case "assistant": {
const text = getTextFromMessageContent(msg.content);

const respId = msg.metadata?.responsesOutputItemId as
| string
| undefined;
const toolCalls = msg.toolCalls as ToolCallDelta[] | undefined;

if (respId && Array.isArray(toolCalls) && toolCalls.length > 0) {
// Emit full function_call output item
const tc = toolCalls[0];
const name = tc?.function?.name as string | undefined;
const args = tc?.function?.arguments as string | undefined;
const call_id = tc?.id as string | undefined;
const functionCallItem: ResponseFunctionToolCall = {
id: respId,
type: "function_call",
name: name || "",
arguments: typeof args === "string" ? args : "{}",
call_id: call_id || respId,
};
input.push(functionCallItem);
} else if (respId) {
// Emit full assistant output message item
const outputMessageItem: ResponseOutputMessage = {
id: respId,
role: "assistant",
type: "message",
status: "completed",
content: [
{
type: "output_text",
text: text || "",
annotations: [],
} satisfies ResponseOutputText,
],
};
input.push(outputMessageItem);
const result = serializeAssistantMessage(msg, stripNextAssistantId);
if (result.type === "item") {
input.push(result.item);
} else {
// Fallback to EasyInput assistant message
pushMessage("assistant", text || "");
pushMessage(result.role, result.content);
}
stripNextAssistantId = false;
break;
}
case "tool": {
Expand All @@ -869,47 +966,22 @@ export function toResponsesInput(messages: ChatMessage[]): ResponseInput {
break;
}
case "thinking": {
const details = (msg as ThinkingChatMessage).reasoning_details ?? [];
if (details.length) {
let id: string | undefined;
let summaryText = "";
let encrypted: string | undefined;
let reasoningText = "";
for (const raw of details as Array<Record<string, unknown>>) {
const d = raw as {
type?: string;
id?: string;
text?: string;
encrypted_content?: string;
};
if (d.type === "reasoning_id" && d.id) id = d.id;
else if (d.type === "encrypted_content" && d.encrypted_content)
encrypted = d.encrypted_content;
else if (d.type === "summary_text" && typeof d.text === "string")
summaryText += d.text;
else if (d.type === "reasoning_text" && typeof d.text === "string")
reasoningText += d.text;
}
if (id) {
const reasoningItem: ResponseReasoningItem = {
id,
type: "reasoning",
summary: [],
} as ResponseReasoningItem;
if (summaryText) {
reasoningItem.summary = [
{ type: "summary_text", text: summaryText },
];
}
if (reasoningText) {
reasoningItem.content = [
{ type: "reasoning_text", text: reasoningText },
];
}
if (encrypted) {
reasoningItem.encrypted_content = encrypted;
}
input.push(reasoningItem as ResponseInputItem);
// Look ahead: check if next assistant message has a responsesOutputItemId reference
const nextMsg = messages[i + 1];
const nextMsgHasReference =
nextMsg?.role === "assistant" &&
nextMsg?.metadata?.responsesOutputItemId !== undefined;

const result = serializeThinkingMessage(
msg as ThinkingChatMessage,
nextMsgHasReference,
);
if (result) {
if (result.type === "skip") {
// Reasoning skipped; strip the ID from the next assistant message
stripNextAssistantId = true;
} else {
input.push(result.item);
}
}
break;
Expand Down
Loading
Loading