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