xonecas.io
64875
Mc

mini-coder / commit 0b5a3db

refactor(llm-api): centralize model routing predicates

xonecas2026-03-14 0b5a3dbe8bacc689485b10ce91b09cfe2b11c161 parent b8aea54

2 files changed

src/llm-api/history-transforms.ts+45−85
@@ -1,4 +1,8 @@
1-import { parseModelString } from "./providers.ts";
1+import {
2+ isGeminiModelFamily,
3+ isOpenAIGPTModelFamily,
4+ isZenOpenAICompatibleChatModel,
5+} from "./model-routing.ts";
26 import type { CoreMessage } from "./turn.ts";
37
48 type StreamChunk = { type?: string; [key: string]: unknown };
@@ -87,24 +91,6 @@ function isToolCallPart(part: unknown): part is Record<string, unknown> {
8791 return isRecord(part) && part.type === "tool-call";
8892 }
8993
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-
10894 function validateGeminiAssistantToolCallMessage(message: CoreMessage): {
10995 valid: boolean;
11096 reason: GeminiToolHistoryRepairReason | null;
@@ -152,10 +138,7 @@ export function getReasoningDeltaFromStreamChunk(
152138 }
153139
154140 export function isOpenAIGPT(modelString: string): boolean {
155- const { provider, modelId } = parseModelString(modelString);
156- return (
157- (provider === "openai" || provider === "zen") && modelId.startsWith("gpt-")
158- );
141+ return isOpenAIGPTModelFamily(modelString);
159142 }
160143
161144 export function stripOpenAIItemIdsFromHistory(
@@ -325,9 +308,10 @@ export function sanitizeGeminiToolMessages(
325308 .messages;
326309 }
327310
328-export function stripGPTCommentaryFromHistory(
311+function stripOpenAIHistory(
329312 messages: CoreMessage[],
330313 modelString: string,
314+ options: { stripItemIds: boolean },
331315 ): CoreMessage[] {
332316 if (!isOpenAIGPT(modelString)) return messages;
333317
@@ -344,85 +328,61 @@ export function stripGPTCommentaryFromHistory(
344328 skipToolResults = false;
345329 }
346330
347- if (message.role !== "assistant" || !Array.isArray(message.content)) {
348- result.push(message);
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);
349353 continue;
350354 }
351355
352- const filtered = message.content.filter(
356+ const filtered = messageForCommentary.content.filter(
353357 (part) => !isCommentaryTextPart(part),
354358 );
355- if (filtered.length === message.content.length) {
356- result.push(message);
359+ if (filtered.length === messageForCommentary.content.length) {
360+ result.push(messageForCommentary);
357361 } else if (filtered.length === 0) {
358362 mutated = true;
359363 skipToolResults = true;
360364 } else {
361365 mutated = true;
362- result.push({ ...message, content: filtered } as CoreMessage);
366+ result.push({
367+ ...messageForCommentary,
368+ content: filtered,
369+ } as CoreMessage);
363370 }
364371 }
365372
366373 return mutated ? result : messages;
367374 }
368375
369-export function stripOpenAIHistoryTransforms(
376+export function stripGPTCommentaryFromHistory(
370377 messages: CoreMessage[],
371378 modelString: string,
372379 ): 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- }
380+ return stripOpenAIHistory(messages, modelString, { stripItemIds: false });
381+}
426382
427- return mutated ? result : messages;
383+export function stripOpenAIHistoryTransforms(
384+ messages: CoreMessage[],
385+ modelString: string,
386+): CoreMessage[] {
387+ return stripOpenAIHistory(messages, modelString, { stripItemIds: true });
428388 }
src/llm-api/model-routing.test.ts+66−0
@@ -0,0 +1,66 @@
1+import { describe, expect, test } from "bun:test";
2+
3+import {
4+ getZenBackend,
5+ isAnthropicModelFamily,
6+ isGeminiModelFamily,
7+ isOpenAIGPTModelFamily,
8+ isOpenAIReasoningModelFamily,
9+ isZenOpenAICompatibleChatModel,
10+ parseModelString,
11+} from "./model-routing.ts";
12+
13+describe("parseModelString", () => {
14+ test("splits provider/model-id", () => {
15+ expect(parseModelString("openai/gpt-4o")).toEqual({
16+ provider: "openai",
17+ modelId: "gpt-4o",
18+ });
19+ });
20+
21+ test("returns empty model id when slash is missing", () => {
22+ expect(parseModelString("openai")).toEqual({
23+ provider: "openai",
24+ modelId: "",
25+ });
26+ });
27+});
28+
29+describe("model family predicates", () => {
30+ test("matches anthropic family", () => {
31+ expect(isAnthropicModelFamily("anthropic/claude-sonnet-4-5")).toBe(true);
32+ expect(isAnthropicModelFamily("zen/claude-sonnet-4-6")).toBe(true);
33+ expect(isAnthropicModelFamily("zen/gpt-5")).toBe(false);
34+ });
35+
36+ test("matches gemini family", () => {
37+ expect(isGeminiModelFamily("google/gemini-2.5-pro")).toBe(true);
38+ expect(isGeminiModelFamily("zen/gemini-3.1-pro")).toBe(true);
39+ expect(isGeminiModelFamily("openai/gpt-4o")).toBe(false);
40+ });
41+
42+ test("matches openai gpt and reasoning families", () => {
43+ expect(isOpenAIGPTModelFamily("openai/gpt-4o")).toBe(true);
44+ expect(isOpenAIGPTModelFamily("zen/gpt-5.3-codex")).toBe(true);
45+ expect(isOpenAIGPTModelFamily("openai/o3")).toBe(false);
46+
47+ expect(isOpenAIReasoningModelFamily("openai/o3")).toBe(true);
48+ expect(isOpenAIReasoningModelFamily("zen/gpt-5.3-codex")).toBe(true);
49+ expect(isOpenAIReasoningModelFamily("google/gemini-2.5-pro")).toBe(false);
50+ });
51+
52+ test("detects zen openai-compatible chat fallback", () => {
53+ expect(isZenOpenAICompatibleChatModel("zen/glm-5")).toBe(true);
54+ expect(isZenOpenAICompatibleChatModel("zen/gpt-4o")).toBe(false);
55+ expect(isZenOpenAICompatibleChatModel("openai/gpt-4o")).toBe(false);
56+ });
57+});
58+
59+describe("getZenBackend", () => {
60+ test("routes by model id prefix", () => {
61+ expect(getZenBackend("claude-sonnet-4-6")).toBe("anthropic");
62+ expect(getZenBackend("gpt-5.3-codex")).toBe("openai");
63+ expect(getZenBackend("gemini-3.1-pro")).toBe("google");
64+ expect(getZenBackend("glm-5")).toBe("compat");
65+ });
66+});