@@ -0,0 +1,428 @@
1+import { parseModelString } from "./providers.ts";
2+import type { CoreMessage } from "./turn.ts";
3+
4+type StreamChunk = { type?: string; [key: string]: unknown };
5+
6+type GeminiToolHistoryRepairReason = "missing-signature-anchor";
7+
8+function isRecord(value: unknown): value is Record<string, unknown> {
9+ return value !== null && typeof value === "object";
10+}
11+
12+function normalizeProviderOptions<T>(part: T): T {
13+ if (!isRecord(part)) return part;
14+ if (
15+ part.providerOptions !== undefined ||
16+ part.providerMetadata === undefined
17+ ) {
18+ return part;
19+ }
20+ return {
21+ ...part,
22+ providerOptions: part.providerMetadata,
23+ } as T;
24+}
25+
26+function normalizeMessageProviderOptions(message: CoreMessage): CoreMessage {
27+ if (!Array.isArray(message.content)) return message;
28+ return {
29+ ...message,
30+ content: message.content.map((part) =>
31+ normalizeProviderOptions(part),
32+ ) as CoreMessage["content"],
33+ } as CoreMessage;
34+}
35+
36+function stripOpenAIItemIdFromPart(part: unknown): {
37+ part: unknown;
38+ changed: boolean;
39+} {
40+ if (!isRecord(part)) return { part, changed: false };
41+
42+ let changed = false;
43+ const nextPart = { ...part };
44+
45+ const dropItemId = (field: "providerOptions" | "providerMetadata"): void => {
46+ const source = nextPart[field];
47+ if (!isRecord(source)) return;
48+ const openai = source.openai;
49+ if (!isRecord(openai) || !("itemId" in openai)) return;
50+
51+ const nextOpenAI = { ...openai };
52+ delete nextOpenAI.itemId;
53+ nextPart[field] = { ...source, openai: nextOpenAI };
54+ changed = true;
55+ };
56+
57+ dropItemId("providerOptions");
58+ dropItemId("providerMetadata");
59+
60+ return { part: changed ? nextPart : part, changed };
61+}
62+
63+function getPartProviderOptions(part: unknown): Record<string, unknown> | null {
64+ if (!isRecord(part)) return null;
65+ if (isRecord(part.providerOptions)) return part.providerOptions;
66+ if (isRecord(part.providerMetadata)) return part.providerMetadata;
67+ return null;
68+}
69+
70+function getGeminiThoughtSignature(part: unknown): string | null {
71+ const providerOptions = getPartProviderOptions(part);
72+ if (!providerOptions) return null;
73+
74+ for (const provider of ["google", "vertex"] as const) {
75+ const metadata = providerOptions[provider];
76+ if (!isRecord(metadata)) continue;
77+ const signature = metadata.thoughtSignature;
78+ if (typeof signature === "string" && signature.length > 0) {
79+ return signature;
80+ }
81+ }
82+
83+ return null;
84+}
85+
86+function isToolCallPart(part: unknown): part is Record<string, unknown> {
87+ return isRecord(part) && part.type === "tool-call";
88+}
89+
90+function isGeminiModelFamily(modelString: string): boolean {
91+ const { provider, modelId } = parseModelString(modelString);
92+ return (
93+ (provider === "google" || provider === "zen") &&
94+ modelId.startsWith("gemini-")
95+ );
96+}
97+
98+function isZenOpenAICompatibleChatModel(modelString: string): boolean {
99+ const { provider, modelId } = parseModelString(modelString);
100+ if (provider !== "zen") return false;
101+ return (
102+ !modelId.startsWith("gpt-") &&
103+ !modelId.startsWith("gemini-") &&
104+ !modelId.startsWith("claude-")
105+ );
106+}
107+
108+function validateGeminiAssistantToolCallMessage(message: CoreMessage): {
109+ valid: boolean;
110+ reason: GeminiToolHistoryRepairReason | null;
111+} {
112+ if (message.role !== "assistant" || !Array.isArray(message.content)) {
113+ return { valid: true, reason: null };
114+ }
115+
116+ let firstToolCallPartSeen = false;
117+ for (const part of message.content) {
118+ if (!isToolCallPart(part)) continue;
119+ if (firstToolCallPartSeen) continue;
120+ firstToolCallPartSeen = true;
121+ if (getGeminiThoughtSignature(part) === null) {
122+ return { valid: false, reason: "missing-signature-anchor" };
123+ }
124+ }
125+
126+ return { valid: true, reason: null };
127+}
128+
129+function getOpenAITextPhase(part: unknown): string | null {
130+ const providerOptions = getPartProviderOptions(part);
131+ if (!providerOptions) return null;
132+ const openai = providerOptions.openai;
133+ if (!isRecord(openai)) return null;
134+ return typeof openai.phase === "string" ? openai.phase : null;
135+}
136+
137+function isCommentaryTextPart(part: unknown): boolean {
138+ if (!isRecord(part) || part.type !== "text") return false;
139+ return getOpenAITextPhase(part) === "commentary";
140+}
141+
142+export function getReasoningDeltaFromStreamChunk(
143+ chunk: StreamChunk,
144+): string | null {
145+ if (chunk.type !== "reasoning-delta" && chunk.type !== "reasoning") {
146+ return null;
147+ }
148+ if (typeof chunk.text === "string") return chunk.text;
149+ if (typeof chunk.textDelta === "string") return chunk.textDelta;
150+ if (typeof chunk.delta === "string") return chunk.delta;
151+ return "";
152+}
153+
154+export function isOpenAIGPT(modelString: string): boolean {
155+ const { provider, modelId } = parseModelString(modelString);
156+ return (
157+ (provider === "openai" || provider === "zen") && modelId.startsWith("gpt-")
158+ );
159+}
160+
161+export function stripOpenAIItemIdsFromHistory(
162+ messages: CoreMessage[],
163+ modelString: string,
164+): CoreMessage[] {
165+ if (!isOpenAIGPT(modelString)) return messages;
166+
167+ let mutated = false;
168+ const result = messages.map((message) => {
169+ if (!Array.isArray(message.content)) return message;
170+
171+ let contentMutated = false;
172+ const content = message.content.map((part) => {
173+ const cleaned = stripOpenAIItemIdFromPart(part);
174+ if (cleaned.changed) contentMutated = true;
175+ return cleaned.part;
176+ });
177+
178+ if (!contentMutated) return message;
179+ mutated = true;
180+ return {
181+ ...message,
182+ content: content as CoreMessage["content"],
183+ } as CoreMessage;
184+ });
185+
186+ return mutated ? result : messages;
187+}
188+
189+export function normalizeOpenAICompatibleToolCallInputs(
190+ messages: CoreMessage[],
191+ modelString: string,
192+): CoreMessage[] {
193+ if (!isZenOpenAICompatibleChatModel(modelString)) return messages;
194+
195+ let mutated = false;
196+ const result = messages.map((message) => {
197+ if (message.role !== "assistant" || !Array.isArray(message.content)) {
198+ return message;
199+ }
200+
201+ let contentMutated = false;
202+ const nextContent = message.content.map((part) => {
203+ if (
204+ !isToolCallPart(part) ||
205+ !("input" in part) ||
206+ typeof part.input !== "string"
207+ ) {
208+ return part;
209+ }
210+
211+ try {
212+ const parsed = JSON.parse(part.input);
213+ if (!isRecord(parsed) || Array.isArray(parsed)) return part;
214+ contentMutated = true;
215+ return {
216+ ...part,
217+ input: parsed,
218+ };
219+ } catch {
220+ return part;
221+ }
222+ });
223+
224+ if (!contentMutated) return message;
225+ mutated = true;
226+ return {
227+ ...message,
228+ content: nextContent as CoreMessage["content"],
229+ } as CoreMessage;
230+ });
231+
232+ return mutated ? result : messages;
233+}
234+
235+export function sanitizeGeminiToolMessagesWithMetadata(
236+ messages: CoreMessage[],
237+ modelString: string,
238+ hasTools: boolean,
239+): {
240+ messages: CoreMessage[];
241+ repaired: boolean;
242+ reason: GeminiToolHistoryRepairReason | null;
243+ repairedFromIndex: number;
244+ droppedMessageCount: number;
245+ tailOnlyAffected: boolean;
246+} {
247+ if (!hasTools || !isGeminiModelFamily(modelString)) {
248+ return {
249+ messages,
250+ repaired: false,
251+ reason: null,
252+ repairedFromIndex: -1,
253+ droppedMessageCount: 0,
254+ tailOnlyAffected: true,
255+ };
256+ }
257+
258+ const normalized = messages.map((message) =>
259+ normalizeMessageProviderOptions(message),
260+ );
261+
262+ for (let index = normalized.length - 1; index >= 0; index -= 1) {
263+ const message = normalized[index];
264+ if (!message) continue;
265+ if (message.role !== "assistant" || !Array.isArray(message.content))
266+ continue;
267+ if (!message.content.some((part) => isToolCallPart(part))) continue;
268+
269+ const validation = validateGeminiAssistantToolCallMessage(message);
270+ if (validation.valid) {
271+ return {
272+ messages: normalized,
273+ repaired: false,
274+ reason: null,
275+ repairedFromIndex: -1,
276+ droppedMessageCount: 0,
277+ tailOnlyAffected: true,
278+ };
279+ }
280+
281+ const nextUserIndex = normalized.findIndex(
282+ (candidate, candidateIndex) =>
283+ candidateIndex > index && candidate?.role === "user",
284+ );
285+ if (nextUserIndex === -1) {
286+ return {
287+ messages: normalized.slice(0, index),
288+ repaired: true,
289+ reason: validation.reason,
290+ repairedFromIndex: index,
291+ droppedMessageCount: normalized.length - index,
292+ tailOnlyAffected: true,
293+ };
294+ }
295+
296+ return {
297+ messages: [
298+ ...normalized.slice(0, index),
299+ ...normalized.slice(nextUserIndex),
300+ ],
301+ repaired: true,
302+ reason: validation.reason,
303+ repairedFromIndex: index,
304+ droppedMessageCount: nextUserIndex - index,
305+ tailOnlyAffected: false,
306+ };
307+ }
308+
309+ return {
310+ messages: normalized,
311+ repaired: false,
312+ reason: null,
313+ repairedFromIndex: -1,
314+ droppedMessageCount: 0,
315+ tailOnlyAffected: true,
316+ };
317+}
318+
319+export function sanitizeGeminiToolMessages(
320+ messages: CoreMessage[],
321+ modelString: string,
322+ hasTools: boolean,
323+): CoreMessage[] {
324+ return sanitizeGeminiToolMessagesWithMetadata(messages, modelString, hasTools)
325+ .messages;
326+}
327+
328+export function stripGPTCommentaryFromHistory(
329+ messages: CoreMessage[],
330+ modelString: string,
331+): CoreMessage[] {
332+ if (!isOpenAIGPT(modelString)) return messages;
333+
334+ let mutated = false;
335+ const result: CoreMessage[] = [];
336+ let skipToolResults = false;
337+
338+ for (const message of messages) {
339+ if (skipToolResults) {
340+ if (message.role === "tool") {
341+ mutated = true;
342+ continue;
343+ }
344+ skipToolResults = false;
345+ }
346+
347+ if (message.role !== "assistant" || !Array.isArray(message.content)) {
348+ result.push(message);
349+ continue;
350+ }
351+
352+ const filtered = message.content.filter(
353+ (part) => !isCommentaryTextPart(part),
354+ );
355+ if (filtered.length === message.content.length) {
356+ result.push(message);
357+ } else if (filtered.length === 0) {
358+ mutated = true;
359+ skipToolResults = true;
360+ } else {
361+ mutated = true;
362+ result.push({ ...message, content: filtered } as CoreMessage);
363+ }
364+ }
365+
366+ return mutated ? result : messages;
367+}
368+
369+export function stripOpenAIHistoryTransforms(
370+ messages: CoreMessage[],
371+ modelString: string,
372+): CoreMessage[] {
373+ if (!isOpenAIGPT(modelString)) return messages;
374+
375+ let mutated = false;
376+ const result: CoreMessage[] = [];
377+ let skipToolResults = false;
378+
379+ for (const message of messages) {
380+ if (skipToolResults) {
381+ if (message.role === "tool") {
382+ mutated = true;
383+ continue;
384+ }
385+ skipToolResults = false;
386+ }
387+
388+ let contentMutated = false;
389+ const strippedContent = Array.isArray(message.content)
390+ ? message.content.map((part) => {
391+ const cleaned = stripOpenAIItemIdFromPart(part);
392+ if (cleaned.changed) contentMutated = true;
393+ return cleaned.part;
394+ })
395+ : message.content;
396+
397+ const msgAfterIdStrip: CoreMessage = contentMutated
398+ ? ({
399+ ...message,
400+ content: strippedContent as CoreMessage["content"],
401+ } as CoreMessage)
402+ : message;
403+
404+ if (contentMutated) mutated = true;
405+
406+ if (
407+ message.role === "assistant" &&
408+ Array.isArray(msgAfterIdStrip.content)
409+ ) {
410+ const filtered = msgAfterIdStrip.content.filter(
411+ (part) => !isCommentaryTextPart(part),
412+ );
413+ if (filtered.length === msgAfterIdStrip.content.length) {
414+ result.push(msgAfterIdStrip);
415+ } else if (filtered.length === 0) {
416+ mutated = true;
417+ skipToolResults = true;
418+ } else {
419+ mutated = true;
420+ result.push({ ...msgAfterIdStrip, content: filtered } as CoreMessage);
421+ }
422+ } else {
423+ result.push(msgAfterIdStrip);
424+ }
425+ }
426+
427+ return mutated ? result : messages;
428+}