xonecas.io
64875
Mc

mini-coder / commit ebd1830

refactor(turn): extract message preparation pipeline

xonecas2026-03-14 ebd183083baa1c8bafc0047f7b51966deb712543 parent aa37ba5

2 files changed

src/llm-api/turn-prepare-messages.ts+141−0
@@ -0,0 +1,141 @@
1+import { isApiLogEnabled, logApiEvent } from "./api-log.ts";
2+import {
3+ normalizeOpenAICompatibleToolCallInputs,
4+ sanitizeGeminiToolMessagesWithMetadata,
5+ stripOpenAIHistoryTransforms,
6+} from "./history-transforms.ts";
7+import { getCacheFamily } from "./provider-options.ts";
8+import type { CoreMessage } from "./turn.ts";
9+import {
10+ annotateAnthropicCacheBreakpoints,
11+ applyContextPruning,
12+ type ContextPruningMode,
13+ compactToolResultPayloads,
14+ getMessageDiagnostics,
15+ getMessageStats,
16+} from "./turn-context.ts";
17+
18+interface PreparedMessages {
19+ messages: CoreMessage[];
20+ systemPrompt: string | undefined;
21+ /** True if context pruning removed any messages. */
22+ pruned: boolean;
23+ prePruneMessageCount: number;
24+ prePruneTotalBytes: number;
25+ postPruneMessageCount: number;
26+ postPruneTotalBytes: number;
27+}
28+
29+/**
30+ * Apply provider-specific history sanitisation, context pruning, and
31+ * payload compaction. Returns the messages ready to send to the model.
32+ */
33+export function prepareTurnMessages(input: {
34+ messages: CoreMessage[];
35+ modelString: string;
36+ toolCount: number;
37+ systemPrompt: string | undefined;
38+ pruningMode: ContextPruningMode;
39+ toolResultPayloadCapBytes: number;
40+ promptCachingEnabled: boolean;
41+}): PreparedMessages {
42+ const {
43+ messages,
44+ modelString,
45+ toolCount,
46+ systemPrompt,
47+ pruningMode,
48+ toolResultPayloadCapBytes,
49+ promptCachingEnabled,
50+ } = input;
51+
52+ const apiLogOn = isApiLogEnabled();
53+
54+ // 1. Provider-specific sanitisation
55+ const geminiResult = sanitizeGeminiToolMessagesWithMetadata(
56+ messages,
57+ modelString,
58+ toolCount > 0,
59+ );
60+ if (geminiResult.repaired && apiLogOn) {
61+ logApiEvent("gemini tool history repaired", {
62+ modelString,
63+ reason: geminiResult.reason,
64+ repairedFromIndex: geminiResult.repairedFromIndex,
65+ droppedMessageCount: geminiResult.droppedMessageCount,
66+ tailOnlyAffected: geminiResult.tailOnlyAffected,
67+ });
68+ }
69+
70+ const openaiStripped = stripOpenAIHistoryTransforms(
71+ geminiResult.messages,
72+ modelString,
73+ );
74+ if (openaiStripped !== geminiResult.messages && apiLogOn) {
75+ logApiEvent("openai history transforms applied", { modelString });
76+ }
77+
78+ const normalised = normalizeOpenAICompatibleToolCallInputs(
79+ openaiStripped,
80+ modelString,
81+ );
82+ if (normalised !== openaiStripped && apiLogOn) {
83+ logApiEvent("openai-compatible tool input normalized", { modelString });
84+ }
85+
86+ // 2. Context pruning
87+ const preStats = apiLogOn
88+ ? getMessageDiagnostics(normalised)
89+ : getMessageStats(normalised);
90+ if (apiLogOn) logApiEvent("turn context pre-prune", preStats);
91+
92+ const pruned = applyContextPruning(normalised, pruningMode);
93+
94+ const postStats = apiLogOn
95+ ? getMessageDiagnostics(pruned)
96+ : getMessageStats(pruned);
97+ if (apiLogOn) logApiEvent("turn context post-prune", postStats);
98+
99+ // 3. Payload compaction
100+ const compacted = compactToolResultPayloads(
101+ pruned,
102+ toolResultPayloadCapBytes,
103+ );
104+ if (compacted !== pruned && apiLogOn) {
105+ logApiEvent("turn context post-compaction", {
106+ capBytes: toolResultPayloadCapBytes,
107+ diagnostics: getMessageDiagnostics(compacted),
108+ });
109+ }
110+
111+ // 4. Anthropic prompt caching breakpoints
112+ let finalMessages = compacted;
113+ let finalSystemPrompt = systemPrompt;
114+
115+ const cacheFamily = getCacheFamily(modelString);
116+ if (cacheFamily === "anthropic" && promptCachingEnabled) {
117+ const annotated = annotateAnthropicCacheBreakpoints(
118+ compacted,
119+ systemPrompt,
120+ );
121+ finalMessages = annotated.messages;
122+ finalSystemPrompt = annotated.systemPrompt;
123+ if (apiLogOn)
124+ logApiEvent("Anthropic prompt caching", annotated.diagnostics);
125+ }
126+
127+ const wasPruned =
128+ (pruningMode === "balanced" || pruningMode === "aggressive") &&
129+ (postStats.messageCount < preStats.messageCount ||
130+ postStats.totalBytes < preStats.totalBytes);
131+
132+ return {
133+ messages: finalMessages,
134+ systemPrompt: finalSystemPrompt,
135+ pruned: wasPruned,
136+ prePruneMessageCount: preStats.messageCount,
137+ prePruneTotalBytes: preStats.totalBytes,
138+ postPruneMessageCount: postStats.messageCount,
139+ postPruneTotalBytes: postStats.totalBytes,
140+ };
141+}
src/llm-api/turn.ts+4−130
@@ -1,21 +1,12 @@
11 import type { FlexibleSchema, StepResult } from "ai";
22 import { dynamicTool, jsonSchema, stepCountIs, streamText } from "ai";
33 import { isApiLogEnabled, logApiEvent } from "./api-log.ts";
4+import type { ThinkingEffort } from "./provider-options.ts";
45 import {
5- normalizeOpenAICompatibleToolCallInputs,
6- sanitizeGeminiToolMessagesWithMetadata,
7- stripOpenAIHistoryTransforms,
8-} from "./history-transforms.ts";
9-import { getCacheFamily, type ThinkingEffort } from "./provider-options.ts";
10-import {
11- annotateAnthropicCacheBreakpoints,
12- applyContextPruning,
136 type ContextPruningMode,
14- compactToolResultPayloads,
157 DEFAULT_TOOL_RESULT_PAYLOAD_CAP_BYTES,
16- getMessageDiagnostics,
17- getMessageStats,
188 } from "./turn-context.ts";
9+import { prepareTurnMessages } from "./turn-prepare-messages.ts";
1910 import { buildTurnProviderOptions } from "./turn-provider-options.ts";
2011
2112 export type { ContextPruningMode } from "./turn-context.ts";
@@ -62,123 +53,6 @@ function toCoreTool(def: ToolDef): ReturnType<typeof dynamicTool> {
6253 });
6354 }
6455
65-// ─── Message preparation pipeline ────────────────────────────────────────────
66-
67-interface PreparedMessages {
68- messages: CoreMessage[];
69- systemPrompt: string | undefined;
70- /** True if context pruning removed any messages. */
71- pruned: boolean;
72- prePruneMessageCount: number;
73- prePruneTotalBytes: number;
74- postPruneMessageCount: number;
75- postPruneTotalBytes: number;
76-}
77-
78-/**
79- * Apply provider-specific history sanitisation, context pruning, and
80- * payload compaction. Returns the messages ready to send to the model.
81- */
82-function prepareMessages(
83- messages: CoreMessage[],
84- modelString: string,
85- toolCount: number,
86- systemPrompt: string | undefined,
87- pruningMode: ContextPruningMode,
88- toolResultPayloadCapBytes: number,
89- promptCachingEnabled: boolean,
90-): PreparedMessages {
91- const apiLogOn = isApiLogEnabled();
92-
93- // 1. Provider-specific sanitisation
94- const geminiResult = sanitizeGeminiToolMessagesWithMetadata(
95- messages,
96- modelString,
97- toolCount > 0,
98- );
99- if (geminiResult.repaired && apiLogOn) {
100- logApiEvent("gemini tool history repaired", {
101- modelString,
102- reason: geminiResult.reason,
103- repairedFromIndex: geminiResult.repairedFromIndex,
104- droppedMessageCount: geminiResult.droppedMessageCount,
105- tailOnlyAffected: geminiResult.tailOnlyAffected,
106- });
107- }
108-
109- const openaiStripped = stripOpenAIHistoryTransforms(
110- geminiResult.messages,
111- modelString,
112- );
113- if (openaiStripped !== geminiResult.messages && apiLogOn) {
114- logApiEvent("openai history transforms applied", { modelString });
115- }
116-
117- const normalised = normalizeOpenAICompatibleToolCallInputs(
118- openaiStripped,
119- modelString,
120- );
121- if (normalised !== openaiStripped && apiLogOn) {
122- logApiEvent("openai-compatible tool input normalized", { modelString });
123- }
124-
125- // 2. Context pruning
126- const preStats = apiLogOn
127- ? getMessageDiagnostics(normalised)
128- : getMessageStats(normalised);
129- if (apiLogOn) logApiEvent("turn context pre-prune", preStats);
130-
131- const pruned = applyContextPruning(normalised, pruningMode);
132-
133- const postStats = apiLogOn
134- ? getMessageDiagnostics(pruned)
135- : getMessageStats(pruned);
136- if (apiLogOn) logApiEvent("turn context post-prune", postStats);
137-
138- // 3. Payload compaction
139- const compacted = compactToolResultPayloads(
140- pruned,
141- toolResultPayloadCapBytes,
142- );
143- if (compacted !== pruned && apiLogOn) {
144- logApiEvent("turn context post-compaction", {
145- capBytes: toolResultPayloadCapBytes,
146- diagnostics: getMessageDiagnostics(compacted),
147- });
148- }
149-
150- // 4. Anthropic prompt caching breakpoints
151- let finalMessages = compacted;
152- let finalSystemPrompt = systemPrompt;
153-
154- const cacheFamily = getCacheFamily(modelString);
155- if (cacheFamily === "anthropic" && promptCachingEnabled) {
156- const annotated = annotateAnthropicCacheBreakpoints(
157- compacted,
158- systemPrompt,
159- );
160- finalMessages = annotated.messages;
161- finalSystemPrompt = annotated.systemPrompt;
162- if (apiLogOn)
163- logApiEvent("Anthropic prompt caching", annotated.diagnostics);
164- }
165-
166- const wasPruned =
167- (pruningMode === "balanced" || pruningMode === "aggressive") &&
168- (postStats.messageCount < preStats.messageCount ||
169- postStats.totalBytes < preStats.totalBytes);
170-
171- return {
172- messages: finalMessages,
173- systemPrompt: finalSystemPrompt,
174- pruned: wasPruned,
175- prePruneMessageCount: preStats.messageCount,
176- prePruneTotalBytes: preStats.totalBytes,
177- postPruneMessageCount: postStats.messageCount,
178- postPruneTotalBytes: postStats.totalBytes,
179- };
180-}
181-
18256 // ─── runTurn ──────────────────────────────────────────────────────────────────
18357
18458 /**
@@ -249,7 +123,7 @@ export async function* runTurn(options: {
249123 });
250124
251125 // Prepare messages: sanitize, prune, compact, annotate cache breakpoints
252- const prepared = prepareMessages(
126+ const prepared = prepareTurnMessages({
253127 messages,
254128 modelString,
255129 toolCount,
@@ -257,7 +131,7 @@ export async function* runTurn(options: {
257131 pruningMode,
258132 toolResultPayloadCapBytes,
259133 promptCachingEnabled,
260- );
134+ });
261135
262136 if (prepared.pruned) {
263137 yield {