Avoid cross-provider thought signatures (#654)

* Avoid cross-provider thought signatures

* Fix Google thought signature replay

Filter thought signatures to same provider with base64 validation and rename the transform helper for clarity.

packages/ai/src/providers/transform-messages.ts

@@ -0,0 +1,144 @@
+import type { Api, AssistantMessage, Message, Model, ToolCall, ToolResultMessage } from "../types.js";
+
+/**
+ * Normalize tool call ID for GitHub Copilot cross-API compatibility.
+ * OpenAI Responses API generates IDs that are 450+ chars with special characters like `|`.
+ * Other APIs (Claude, etc.) require max 40 chars and only alphanumeric + underscore + hyphen.
+ */
+function normalizeCopilotToolCallId(id: string): string {
+	return id.replace(/[^a-zA-Z0-9_-]/g, "").slice(0, 40);
+}
+
+export function transformMessages<TApi extends Api>(messages: Message[], model: Model<TApi>): Message[] {
+	// Build a map of original tool call IDs to normalized IDs for github-copilot cross-API switches
+	const toolCallIdMap = new Map<string, string>();
+
+	// First pass: transform messages (thinking blocks, tool call ID normalization)
+	const transformed = messages.map((msg) => {
+		// User messages pass through unchanged
+		if (msg.role === "user") {
+			return msg;
+		}
+
+		// Handle toolResult messages - normalize toolCallId if we have a mapping
+		if (msg.role === "toolResult") {
+			const normalizedId = toolCallIdMap.get(msg.toolCallId);
+			if (normalizedId && normalizedId !== msg.toolCallId) {
+				return { ...msg, toolCallId: normalizedId };
+			}
+			return msg;
+		}
+
+		// Assistant messages need transformation check
+		if (msg.role === "assistant") {
+			const assistantMsg = msg as AssistantMessage;
+
+			// If message is from the same provider and API, keep as is
+			if (assistantMsg.provider === model.provider && assistantMsg.api === model.api) {
+				return msg;
+			}
+
+			// Check if we need to normalize tool call IDs (github-copilot cross-API)
+			const needsToolCallIdNormalization =
+				assistantMsg.provider === "github-copilot" &&
+				model.provider === "github-copilot" &&
+				assistantMsg.api !== model.api;
+
+			// Transform message from different provider/model
+			const transformedContent = assistantMsg.content.flatMap((block) => {
+				if (block.type === "thinking") {
+					// Skip empty thinking blocks, convert others to plain text
+					if (!block.thinking || block.thinking.trim() === "") return [];
+					return {
+						type: "text" as const,
+						text: block.thinking,
+					};
+				}
+				// Normalize tool call IDs for github-copilot cross-API switches
+				if (block.type === "toolCall" && needsToolCallIdNormalization) {
+					const toolCall = block as ToolCall;
+					const normalizedId = normalizeCopilotToolCallId(toolCall.id);
+					if (normalizedId !== toolCall.id) {
+						toolCallIdMap.set(toolCall.id, normalizedId);
+						return { ...toolCall, id: normalizedId };
+					}
+				}
+				// All other blocks pass through unchanged
+				return block;
+			});
+
+			// Return transformed assistant message
+			return {
+				...assistantMsg,
+				content: transformedContent,
+			};
+		}
+		return msg;
+	});
+
+	// Second pass: insert synthetic empty tool results for orphaned tool calls
+	// This preserves thinking signatures and satisfies API requirements
+	const result: Message[] = [];
+	let pendingToolCalls: ToolCall[] = [];
+	let existingToolResultIds = new Set<string>();
+
+	for (let i = 0; i < transformed.length; i++) {
+		const msg = transformed[i];
+
+		if (msg.role === "assistant") {
+			// If we have pending orphaned tool calls from a previous assistant, insert synthetic results now
+			if (pendingToolCalls.length > 0) {
+				for (const tc of pendingToolCalls) {
+					if (!existingToolResultIds.has(tc.id)) {
+						result.push({
+							role: "toolResult",
+							toolCallId: tc.id,
+							toolName: tc.name,
+							content: [{ type: "text", text: "No result provided" }],
+							isError: true,
+							timestamp: Date.now(),
+						} as ToolResultMessage);
+					}
+				}
+				pendingToolCalls = [];
+				existingToolResultIds = new Set();
+			}
+
+			// Track tool calls from this assistant message
+			const assistantMsg = msg as AssistantMessage;
+			const toolCalls = assistantMsg.content.filter((b) => b.type === "toolCall") as ToolCall[];
+			if (toolCalls.length > 0) {
+				pendingToolCalls = toolCalls;
+				existingToolResultIds = new Set();
+			}
+
+			result.push(msg);
+		} else if (msg.role === "toolResult") {
+			existingToolResultIds.add(msg.toolCallId);
+			result.push(msg);
+		} else if (msg.role === "user") {
+			// User message interrupts tool flow - insert synthetic results for orphaned calls
+			if (pendingToolCalls.length > 0) {
+				for (const tc of pendingToolCalls) {
+					if (!existingToolResultIds.has(tc.id)) {
+						result.push({
+							role: "toolResult",
+							toolCallId: tc.id,
+							toolName: tc.name,
+							content: [{ type: "text", text: "No result provided" }],
+							isError: true,
+							timestamp: Date.now(),
+						} as ToolResultMessage);
+					}
+				}
+				pendingToolCalls = [];
+				existingToolResultIds = new Set();
+			}
+			result.push(msg);
+		} else {
+			result.push(msg);
+		}
+	}
+
+	return result;
+}