fix: resolve 3 cherry-pick issues from batch-2

Issue A — Missing rooMessage.ts (blocked 31 test files):
- Created src/core/task-persistence/rooMessage.ts with standalone type
  definitions (pre-AI-SDK compatible, no 'ai' package imports)
- Added readRooMessages/saveRooMessages/detectFormat to apiMessages.ts
  with v2 envelope format support
- Updated index.ts to export the new functions
- Removed dangling exports for missing converters/anthropicToRoo and messageUtils

Issue B — ClineProvider.ts syntax error (blocked type check):
- Replaced entire reopenParentFromDelegation() method which had severe
  merge damage: duplicate code sections (steps 3-8 appeared twice),
  missing parentClineMessages declaration, unclosed for loop, missing
  outer try block
- Fixed getTaskWithId() to use readRooMessages instead of raw JSON.parse
  to support v2 envelope format
- Fixed type cast in validateAndFixToolResultIds call

Issue C — gemini.spec.ts mockStreamText references (3 test failures):
- Removed import of NoOutputGeneratedError from 'ai' (not in pre-AI-SDK)
- Rewrote 3 tests to use generateContentStream mock pattern consistent
  with other tests in the file instead of AI-SDK mockStreamText
- Added saveDelegationMeta mock to history-resume-delegation.spec.ts

Author: hannesrudolph

src/__tests__/history-resume-delegation.spec.ts

@@ -36,6 +36,15 @@ vi.mock("../core/task-persistence", async (importOriginal) => {
 		readRooMessages: vi.fn().mockResolvedValue([]),
 		saveRooMessages: vi.fn().mockResolvedValue(undefined),
 		saveTaskMessages: vi.fn().mockResolvedValue(undefined),
+		saveDelegationMeta: vi.fn().mockResolvedValue(undefined),
+	}
+})
+vi.mock("../core/task-persistence/delegationMeta", async (importOriginal) => {
+	const actual = await importOriginal<typeof import("../core/task-persistence/delegationMeta")>()
+	return {
+		...actual,
+		saveDelegationMeta: vi.fn().mockResolvedValue(undefined),
+		readDelegationMeta: vi.fn().mockResolvedValue(null),
 	}
 })
 

src/api/providers/__tests__/gemini.spec.ts

@@ -1,7 +1,5 @@
 // npx vitest run src/api/providers/__tests__/gemini.spec.ts
 
-import { NoOutputGeneratedError } from "ai"
-
 const mockCaptureException = vitest.fn()
 
 vitest.mock("@roo-code/telemetry", () => ({
@@ -106,15 +104,11 @@ describe("GeminiHandler", () => {
 		})
 
 		it("should yield informative message when stream produces no text content", async () => {
-			// Stream with only reasoning (no text-delta) simulates thinking-only response
-			const mockFullStream = (async function* () {
-				yield { type: "reasoning-delta", id: "1", text: "thinking..." }
-			})()
-
-			mockStreamText.mockReturnValue({
-				fullStream: mockFullStream,
-				usage: Promise.resolve({ inputTokens: 10, outputTokens: 0 }),
-				providerMetadata: Promise.resolve({}),
+			// Stream with only usageMetadata (no text parts) simulates thinking-only response
+			;(handler["client"].models.generateContentStream as any).mockResolvedValue({
+				[Symbol.asyncIterator]: async function* () {
+					yield { usageMetadata: { promptTokenCount: 10, candidatesTokenCount: 0 } }
+				},
 			})
 
 			const stream = handler.createMessage(systemPrompt, mockMessages)
@@ -124,7 +118,7 @@ describe("GeminiHandler", () => {
 				chunks.push(chunk)
 			}
 
-			// Should have: reasoning chunk, empty-stream informative message, usage
+			// Should have: empty-stream informative message, usage
 			const textChunks = chunks.filter((c) => c.type === "text")
 			expect(textChunks).toHaveLength(1)
 			expect(textChunks[0]).toEqual({
@@ -133,27 +127,23 @@ describe("GeminiHandler", () => {
 			})
 		})
 
-		it("should suppress NoOutputGeneratedError when no text content was yielded", async () => {
-			// Empty stream - nothing yielded at all
-			const mockFullStream = (async function* () {
-				// empty stream
-			})()
-
-			mockStreamText.mockReturnValue({
-				fullStream: mockFullStream,
-				usage: Promise.reject(new NoOutputGeneratedError({ message: "No output generated." })),
-				providerMetadata: Promise.resolve({}),
+		it("should yield informative message when stream is completely empty", async () => {
+			// Completely empty stream - no chunks yielded at all
+			;(handler["client"].models.generateContentStream as any).mockResolvedValue({
+				[Symbol.asyncIterator]: async function* () {
+					// empty stream
+				},
 			})
 
 			const stream = handler.createMessage(systemPrompt, mockMessages)
 			const chunks = []
 
-			// Should NOT throw - the error is suppressed
+			// Should NOT throw
 			for await (const chunk of stream) {
 				chunks.push(chunk)
 			}
 
-			// Should have the informative empty-stream message only (no usage since it errored)
+			// Should have the informative empty-stream message
 			const textChunks = chunks.filter((c) => c.type === "text")
 			expect(textChunks).toHaveLength(1)
 			expect(textChunks[0]).toMatchObject({
@@ -162,25 +152,26 @@ describe("GeminiHandler", () => {
 			})
 		})
 
-		it("should re-throw NoOutputGeneratedError when text content was yielded", async () => {
-			// Stream yields text content but usage still throws NoOutputGeneratedError (unexpected)
-			const mockFullStream = (async function* () {
-				yield { type: "text-delta", text: "Hello" }
-			})()
-
-			mockStreamText.mockReturnValue({
-				fullStream: mockFullStream,
-				usage: Promise.reject(new NoOutputGeneratedError({ message: "No output generated." })),
-				providerMetadata: Promise.resolve({}),
+		it("should not yield empty-response message when text content was produced", async () => {
+			// Stream yields actual text content - should NOT get the informative message
+			;(handler["client"].models.generateContentStream as any).mockResolvedValue({
+				[Symbol.asyncIterator]: async function* () {
+					yield { text: "Hello" }
+					yield { usageMetadata: { promptTokenCount: 10, candidatesTokenCount: 5 } }
+				},
 			})
 
 			const stream = handler.createMessage(systemPrompt, mockMessages)
+			const chunks = []
 
-			await expect(async () => {
-				for await (const _chunk of stream) {
-					// consume stream
-				}
-			}).rejects.toThrow()
+			for await (const chunk of stream) {
+				chunks.push(chunk)
+			}
+
+			// Should have text and usage, but NOT the empty-response informative message
+			const textChunks = chunks.filter((c) => c.type === "text")
+			expect(textChunks).toHaveLength(1)
+			expect(textChunks[0]).toEqual({ type: "text", text: "Hello" })
 		})
 
 		it("should handle API errors", async () => {

src/core/task-persistence/apiMessages.ts

@@ -8,6 +8,7 @@ import { fileExistsAtPath } from "../../utils/fs"
 
 import { GlobalFileNames } from "../../shared/globalFileNames"
 import { getTaskDirectoryPath } from "../../utils/storage"
+import type { RooMessage } from "./rooMessage"
 
 export type ApiMessage = Anthropic.MessageParam & {
 	ts?: number
@@ -119,3 +120,114 @@ export async function saveApiMessages({
 	const filePath = path.join(taskDir, GlobalFileNames.apiConversationHistory)
 	await safeWriteJson(filePath, messages)
 }
+
+/**
+ * Detect the on-disk format of persisted messages.
+ * Returns "v2" if the data is a versioned RooMessageHistory envelope,
+ * "legacy" otherwise.
+ */
+export function detectFormat(parsedData: unknown): "legacy" | "v2" {
+	if (
+		parsedData &&
+		typeof parsedData === "object" &&
+		"version" in parsedData &&
+		(parsedData as { version: unknown }).version === 2 &&
+		"messages" in parsedData &&
+		Array.isArray((parsedData as { messages: unknown }).messages)
+	) {
+		return "v2"
+	}
+	return "legacy"
+}
+
+/**
+ * Read messages from disk and return them as RooMessage[].
+ * Handles both v2 envelope format ({version: 2, messages: [...]}) and
+ * legacy Anthropic array format.
+ */
+export async function readRooMessages({
+	taskId,
+	globalStoragePath,
+}: {
+	taskId: string
+	globalStoragePath: string
+}): Promise<RooMessage[]> {
+	const taskDir = await getTaskDirectoryPath(globalStoragePath, taskId)
+	const filePath = path.join(taskDir, GlobalFileNames.apiConversationHistory)
+
+	const tryParseFile = async (targetPath: string): Promise<RooMessage[] | null> => {
+		if (!(await fileExistsAtPath(targetPath))) {
+			return null
+		}
+
+		const fileContent = await fs.readFile(targetPath, "utf8")
+		let parsedData: unknown
+
+		try {
+			parsedData = JSON.parse(fileContent)
+		} catch (error) {
+			console.warn(
+				`[readRooMessages] Error parsing file, returning empty. TaskId: ${taskId}, Path: ${targetPath}, Error: ${error}`,
+			)
+			return []
+		}
+
+		const format = detectFormat(parsedData)
+
+		if (format === "v2") {
+			return (parsedData as { version: number; messages: RooMessage[] }).messages
+		}
+
+		if (!Array.isArray(parsedData)) {
+			console.warn(
+				`[readRooMessages] Parsed data is not an array (got ${typeof parsedData}), returning empty. TaskId: ${taskId}, Path: ${targetPath}`,
+			)
+			return []
+		}
+
+		// Legacy format: cast through as compatible
+		return parsedData as unknown as RooMessage[]
+	}
+
+	const primaryResult = await tryParseFile(filePath)
+	if (primaryResult !== null) {
+		return primaryResult
+	}
+
+	const oldPath = path.join(taskDir, "claude_messages.json")
+	const fallbackResult = await tryParseFile(oldPath)
+	if (fallbackResult !== null) {
+		return fallbackResult
+	}
+
+	console.error(
+		`[Roo-Debug] readRooMessages: API conversation history file not found for taskId: ${taskId}. Expected at: ${filePath}`,
+	)
+	return []
+}
+
+/**
+ * Save RooMessage[] to disk.
+ * In the pre-AI-SDK codebase this is a thin wrapper around saveApiMessages
+ * that casts through any since the on-disk format is compatible.
+ */
+export async function saveRooMessages({
+	messages,
+	taskId,
+	globalStoragePath,
+}: {
+	messages: RooMessage[]
+	taskId: string
+	globalStoragePath: string
+}): Promise<boolean> {
+	try {
+		await saveApiMessages({
+			messages: messages as unknown as ApiMessage[],
+			taskId,
+			globalStoragePath,
+		})
+		return true
+	} catch {
+		return false
+	}
+}

src/core/task-persistence/index.ts

@@ -1,4 +1,5 @@
 export { type ApiMessage, readApiMessages, saveApiMessages } from "./apiMessages"
+export { detectFormat, readRooMessages, saveRooMessages } from "./apiMessages"
 export { readTaskMessages, saveTaskMessages } from "./taskMessages"
 export { taskMetadata } from "./taskMetadata"
 export type { RooMessage, RooMessageHistory, RooMessageMetadata } from "./rooMessage"
@@ -33,6 +34,4 @@ export {
 	getToolResultIsError,
 	setToolResultCallId,
 } from "./rooMessage"
-export { convertAnthropicToRooMessages } from "./converters/anthropicToRoo"
-export { flattenModelMessagesToStringContent } from "./messageUtils"
 export { type DelegationMeta, readDelegationMeta, saveDelegationMeta } from "./delegationMeta"