perf(tools): optimize last-user message extraction

[aymuos15]

Summary

• Consolidates 4 duplicated "find last user message + extract text" implementations into 3 shared helpers in memory-client.ts: findLastUserMessage(), extractTextFromMessageContent(), and joinTextParts()
• Replaces slice().reverse().find() with Array.findLast() — avoids O(n) allocation on every call
• Net change: Single source of truth across OpenAI middleware, Vercel AI SDK, and shared memory client

Benchmark results

Environment: 12th Gen Intel i7-12800H, Bun 1.2.22, Linux x64

getLastUserMessage (string content)

Scenario	Messages	Old (slice/reverse/find)	New (findLast)	Speedup
User at END (best)	11	27.58 ns	5.51 ns	5.0x
User at END (best)	101	135.43 ns	6.25 ns	21.7x
User at END (best)	1001	1.30 µs	7.10 ns	183x
User at START (worst)	11	44.09 ns	24.25 ns	1.8x
User at START (worst)	101	309.59 ns	151.72 ns	2.0x
User at START (worst)	1001	2.83 µs	1.28 µs	2.2x

extractQueryText (multipart content)

Scenario	Messages	Old (slice/reverse + filter/map/join)	New (findLast + extractText)	Speedup
User at END	11	106.54 ns	92.27 ns	1.2x
User at END	101	215.01 ns	77.88 ns	2.8x
User at END	1001	1.65 µs	77.25 ns	21.4x
User at START	11	148.09 ns	104.59 ns	1.4x
User at START	101	355.13 ns	217.46 ns	1.6x
User at START	1001	2.79 µs	1.32 µs	2.1x

Key takeaways

• Best case (user message at end) shows the largest wins — up to 183x for getLastUserMessage at 1001 messages — because findLast short-circuits immediately while the old approach always allocates a full copy via slice().reverse()
• Worst case (single user message at index 0) still shows a consistent ~2x improvement since findLast avoids the allocation overhead even when both approaches scan the full array
• Zero allocations in the new path for the common case (0 bytes vs up to 8 KB for 1001 messages)

Benchmark source code

import { bench, group, run } from "mitata"

// --- Shared type ---

type Msg = {
	role: string
	content: string | Array<{ type: string; text?: string }>
}

// --- Old implementations (slice/reverse/find) ---

const getLastUserMessage_old = (messages: Msg[]) => {
	const lastUserMessage = messages
		.slice()
		.reverse()
		.find((msg) => msg.role === "user")

	return typeof lastUserMessage?.content === "string"
		? lastUserMessage.content
		: ""
}

const extractQueryText_old = (messages: Msg[]): string => {
	const userMessage = messages
		.slice()
		.reverse()
		.find((msg) => msg.role === "user")

	const content = userMessage?.content
	if (!content) return ""

	if (typeof content === "string") {
		return content
	}

	return content
		.filter((part) => part.type === "text")
		.map((part) => part.text || "")
		.join(" ")
}

// --- New implementations (matches shipped code: findLast + extractTextFromMessageContent) ---

const joinTextParts = (parts: Array<{ type: string; text?: string }>): string =>
	parts
		.filter((p) => p.type === "text")
		.map((p) => p.text ?? "")
		.join(" ")

const findLastUserMessage = <T extends { role: string }>(
	messages: T[],
): T | undefined => {
	for (let i = messages.length - 1; i >= 0; i--) {
		if (messages[i]?.role === "user") return messages[i]
	}
	return undefined
}

const extractTextFromMessageContent = (
	content: unknown,
): string | undefined => {
	if (typeof content === "string") {
		return content
	}

	if (Array.isArray(content)) {
		return joinTextParts(content as Array<{ type: string; text?: string }>)
	}

	const objContent = content as {
		content?: string
		parts?: Array<{ type: string; text?: string }>
	} | null
	if (typeof objContent === "object" && objContent !== null) {
		if (typeof objContent.content === "string") {
			return objContent.content
		}
		if (Array.isArray(objContent.parts)) {
			return joinTextParts(objContent.parts)
		}
	}

	return undefined
}

const getLastUserMessage_new = (messages: Msg[]) => {
	const userMessage = findLastUserMessage(messages)
	if (!userMessage) return ""
	return extractTextFromMessageContent(userMessage.content) ?? ""
}

const extractQueryText_new = (messages: Msg[]): string => {
	const userMessage = findLastUserMessage(messages)
	if (!userMessage) return ""
	return extractTextFromMessageContent(userMessage.content) ?? ""
}

// --- Test data generators ---

function makeMessages_userAtEnd(n: number): Msg[] {
	const msgs: Msg[] = []
	for (let i = 0; i < n; i++) {
		msgs.push(
			{ role: "user", content: `user message ${i}` },
			{ role: "assistant", content: `assistant response ${i}` },
		)
	}
	msgs.push({ role: "user", content: "final question" })
	return msgs
}

function makeMessages_userAtStart(n: number): Msg[] {
	const msgs: Msg[] = [{ role: "user", content: "only user message" }]
	for (let i = 0; i < n - 1; i++) {
		msgs.push({ role: "assistant", content: `assistant response ${i}` })
	}
	return msgs
}

function makePartsMessages_userAtEnd(n: number): Msg[] {
	const msgs: Msg[] = []
	for (let i = 0; i < n; i++) {
		msgs.push(
			{
				role: "user",
				content: [
					{ type: "text", text: `part A ${i}` },
					{ type: "image" },
					{ type: "text", text: `part B ${i}` },
				],
			},
			{ role: "assistant", content: `response ${i}` },
		)
	}
	msgs.push({
		role: "user",
		content: [
			{ type: "text", text: "final part A" },
			{ type: "file" },
			{ type: "text", text: "final part B" },
		],
	})
	return msgs
}

function makePartsMessages_userAtStart(n: number): Msg[] {
	const msgs: Msg[] = [
		{
			role: "user",
			content: [
				{ type: "text", text: "only part A" },
				{ type: "file" },
				{ type: "text", text: "only part B" },
			],
		},
	]
	for (let i = 0; i < n - 1; i++) {
		msgs.push({ role: "assistant", content: `response ${i}` })
	}
	return msgs
}

// --- Correctness checks ---

function assert(cond: boolean, msg: string) {
	if (!cond) throw new Error(`Assertion failed: ${msg}`)
}

for (const n of [5, 50, 500]) {
	const endMsgs = makeMessages_userAtEnd(n)
	const startMsgs = makeMessages_userAtStart(n * 2 + 1)
	const endParts = makePartsMessages_userAtEnd(n)
	const startParts = makePartsMessages_userAtStart(n * 2 + 1)

	assert(
		getLastUserMessage_old(endMsgs) === getLastUserMessage_new(endMsgs),
		`getLastUserMessage mismatch (userAtEnd, n=${n})`,
	)
	assert(
		getLastUserMessage_old(startMsgs) === getLastUserMessage_new(startMsgs),
		`getLastUserMessage mismatch (userAtStart, n=${n})`,
	)
	assert(
		extractQueryText_old(endParts) === extractQueryText_new(endParts),
		`extractQueryText mismatch (userAtEnd, n=${n})`,
	)
	assert(
		extractQueryText_old(startParts) === extractQueryText_new(startParts),
		`extractQueryText mismatch (userAtStart, n=${n})`,
	)
}
console.log("✓ All correctness checks passed\n")

// --- Prepare data ---

const [strEnd11, strEnd101, strEnd1001] = [
	makeMessages_userAtEnd(5),
	makeMessages_userAtEnd(50),
	makeMessages_userAtEnd(500),
] as const

const [strStart11, strStart101, strStart1001] = [
	makeMessages_userAtStart(11),
	makeMessages_userAtStart(101),
	makeMessages_userAtStart(1001),
] as const

const [partsEnd11, partsEnd101, partsEnd1001] = [
	makePartsMessages_userAtEnd(5),
	makePartsMessages_userAtEnd(50),
	makePartsMessages_userAtEnd(500),
] as const

const [partsStart11, partsStart101, partsStart1001] = [
	makePartsMessages_userAtStart(11),
	makePartsMessages_userAtStart(101),
	makePartsMessages_userAtStart(1001),
] as const

// --- Benchmarks ---

for (const [n, msgs] of [
	[11, strEnd11],
	[101, strEnd101],
	[1001, strEnd1001],
] as const) {
	group(`getLastUserMessage – ${n} msgs – user at END (best case)`, () => {
		bench("old (slice/reverse/find)", () => getLastUserMessage_old(msgs))
		bench("new (findLast)", () => getLastUserMessage_new(msgs))
	})
}

for (const [n, msgs] of [
	[11, strStart11],
	[101, strStart101],
	[1001, strStart1001],
] as const) {
	group(`getLastUserMessage – ${n} msgs – user at START (worst case)`, () => {
		bench("old (slice/reverse/find)", () => getLastUserMessage_old(msgs))
		bench("new (findLast)", () => getLastUserMessage_new(msgs))
	})
}

for (const [n, msgs] of [
	[11, partsEnd11],
	[101, partsEnd101],
	[1001, partsEnd1001],
] as const) {
	group(`extractQueryText – ${n} msgs – user at END`, () => {
		bench("old (slice/reverse + filter/map/join)", () =>
			extractQueryText_old(msgs),
		)
		bench("new (findLast + extractText)", () => extractQueryText_new(msgs))
	})
}

for (const [n, msgs] of [
	[11, partsStart11],
	[101, partsStart101],
	[1001, partsStart1001],
] as const) {
	group(`extractQueryText – ${n} msgs – user at START`, () => {
		bench("old (slice/reverse + filter/map/join)", () =>
			extractQueryText_old(msgs),
		)
		bench("new (findLast + extractText)", () => extractQueryText_new(msgs))
	})
}

await run()

Test plan

• Correctness assertions verify old and new implementations produce identical output across 5, 50, and 500 message arrays (see benchmark source above)
• Existing unit tests pass (bun run test in packages/tools) — 43 passed, 29 skipped; 2 pre-existing failures unrelated to this PR (missing SUPERMEMORY_API_KEY env var, missing ./claude-memory test module)
• Type checks pass (bun run check-types) — zero errors in source files
• Biome lint/format pass

[MaheshtheDev]

@aymuos15 can you look into this review suggestion

[aymuos15]

Have addressed this now. Thanks!