pruneMessages doesn't work well with OpenAI reasoning models

[pouljohn1]

Context

OpenAI requires both reasoning parts and tool call parts when sending messages to it's responses API.

When you strip reasoning parts then request fails with error:

Item 'fc_06124fefef59a7bc006939630d68f08196875270e343d65c39' of type 'function_call' was provided without its required 'reasoning' item: 'rs_06124fefef59a7bc0069396307aba48196a895e6104fb0d7da'.

In the other hand when you strip tool call parts but leave reasoning it fails with error:

Item 'rs_06124fefef59a7bc006939624618b88196918727e605c4cfdf' of type 'reasoning' was provided without its required following item.

Related code

pruneMessages works in a way that it just removes reasoning parts or tool call parts from message content. Related pruneMessages implementation:

if (reasoning === 'all' || reasoning === 'before-last-message') {
    messages = messages.map((message, messageIndex) => {
      if (
        message.role !== 'assistant' ||
        typeof message.content === 'string' ||
        (reasoning === 'before-last-message' &&
          messageIndex === messages.length - 1)
      ) {
        return message;
      }

      return {
        ...message,
        content: message.content.filter(part => part.type !== 'reasoning'),
      };
    });
  }

Reproducing step

streamText({
    model: openai('gpt-5.1')
    providerOptions: {
        openai: {
            reasoningEffort: 'medium',
        }
    },
    prepareStep: async ({ steps, messages }) => {
        const prunedMessages = pruneMessages({
            messages,
            reasoning: 'all',
        })
        return { messages: prunedMessages }     
    },
    tools: {
        someToolThatNeedsToBeCallend
    }
})

How to Fix

I think the best would be to remove all the content if there is reasoning for it. But it will break logic of what there is in pruneMessages now.

AI SDK Version

• ai: 5.0.108
• ai-sdk/react: 2.0.109
• ai-sdk/openai: 2.0.80

Code of Conduct

• I agree to follow this project's Code of Conduct

[lgrammel]

With OpenAI reasoning models such pruning is likely not required. Which problems are you running into with those models specifically that require context pruning?

[pouljohn1]

@lgrammel Thanks for a reply! I am not an expert here. Why you say that it is not required?

I am using it for limiting context and input tokens usages. Creating something like v0 for documents and courses where user can have very long conversation and there can be lot of tokens in tool calls (e.g. read a file).

[lgrammel]

Usually OpenAI uses methods like previousResponseId and stateful message ids but your point re token cost makes sense. Unfortunately there signing makes it rather hard to prune the messages, you would need to remove both tool calls and reasoning otherwise you break their signatures. Please let me know if you have a solution that I am not aware of.

[pouljohn1]

@lgrammel I think you are correct and that is what I am doing now. I've created pruneMessages function that is only for openai models. Possibly that it could be done by changing current pruneMessages implementation but it will for sure require changing api for it (model based approach).

Leaving it if someone will need such thing:

import type { ModelMessage } from 'ai'

export default function pruneOpenAiMessages({
    messages,
    keepLastReasoningCount = 0,
    toolCalls = [],
    emptyMessages = 'remove',
}: {
    messages: ModelMessage[]
    keepLastReasoningCount?: number
    toolCalls?: Array<{
        keepLastMessagesCount: number
        tools?: string[]
    }>
    emptyMessages?: 'keep' | 'remove'
}): ModelMessage[] {
    // filter reasoning parts:
    if (keepLastReasoningCount) {
        messages = messages.filter((message, messageIndex) => {
            if (
                message.role !== 'assistant' ||
                typeof message.content === 'string' ||
                messageIndex >= messages.length - keepLastReasoningCount
            ) {
                return true
            }

            if (message.content.find((part) => part.type === 'reasoning')) {
                return false
            }

            return true
        })
    }

    for (const toolCall of toolCalls) {
        // determine how many trailing messages to keep:
        const keepLastMessagesCount = toolCall.keepLastMessagesCount

        // scan kept messages to identify tool calls and approvals that need to be kept:
        const keptToolCallIds: Set<string> = new Set()

        if (keepLastMessagesCount != null) {
            for (const message of messages.slice(-keepLastMessagesCount)) {
                if (
                    (message.role === 'assistant' || message.role === 'tool') &&
                    typeof message.content !== 'string'
                ) {
                    for (const part of message.content) {
                        if (
                            part.type === 'tool-call' ||
                            part.type === 'tool-result'
                        ) {
                            keptToolCallIds.add(part.toolCallId)
                        }
                    }
                }
            }
        }

        messages = messages.filter((message, messageIndex) => {
            if (
                (message.role !== 'assistant' && message.role !== 'tool') ||
                typeof message.content === 'string' ||
                (keepLastMessagesCount &&
                    messageIndex >= messages.length - keepLastMessagesCount)
            ) {
                return message
            }

            const shouldRemove = message.content.find((part) => {
                // keep non-tool parts:
                if (part.type !== 'tool-call' && part.type !== 'tool-result') {
                    return false
                }

                // keep parts that are associated with a tool call that needs to be kept:
                if (keptToolCallIds.has(part.toolCallId)) {
                    return false
                }

                // If no specific tools specified, remove ALL tool calls before threshold
                if (!toolCall.tools) {
                    return true
                }

                // Get tool name (tool-call has it directly, tool-result needs lookup or has toolName)
                const toolName =
                    part.type === 'tool-call'
                        ? part.toolName
                        : (part as { toolName?: string }).toolName

                // Remove if this tool is in the removal list
                if (toolName && toolCall.tools.includes(toolName)) {
                    return true
                }

                return false
            })

            return !shouldRemove
        })
    }

    if (emptyMessages === 'remove') {
        messages = messages.filter((message) => message.content.length > 0)
    }

    return messages
}