xonecas.io
64875
Mc

mini-coder / commit b18f045

refactor(llm-api): extract turn preparation and stream request builder

xonecas2026-03-14 b18f0451d1b7121bd3996ba6847611829751d7d5 parent fca0a0d

2 files changed

src/llm-api/turn-request.ts+90−0
@@ -0,0 +1,90 @@
1+import { stepCountIs, type streamText } from "ai";
2+
3+import type { ThinkingEffort } from "./provider-options.ts";
4+import type { ContextPruningMode } from "./turn-context.ts";
5+import { prepareTurnMessages } from "./turn-prepare-messages.ts";
6+import { buildTurnProviderOptions } from "./turn-provider-options.ts";
7+
8+type StreamTextOptions = Parameters<typeof streamText>[0];
9+type CoreMessage = NonNullable<StreamTextOptions["messages"]>[number];
10+type CoreModel = StreamTextOptions["model"];
11+type ToolSet = NonNullable<StreamTextOptions["tools"]>;
12+
13+interface BuildTurnPreparationInput {
14+ modelString: string;
15+ messages: CoreMessage[];
16+ thinkingEffort: ThinkingEffort | undefined;
17+ promptCachingEnabled: boolean;
18+ openaiPromptCacheRetention: "in_memory" | "24h";
19+ googleCachedContent: string | null;
20+ toolCount: number;
21+ systemPrompt: string | undefined;
22+ pruningMode: ContextPruningMode;
23+ toolResultPayloadCapBytes: number;
24+}
25+
26+export function buildTurnPreparation(input: BuildTurnPreparationInput): {
27+ providerOptionsResult: ReturnType<typeof buildTurnProviderOptions>;
28+ prepared: ReturnType<typeof prepareTurnMessages>;
29+} {
30+ const providerOptionsResult = buildTurnProviderOptions({
31+ modelString: input.modelString,
32+ thinkingEffort: input.thinkingEffort,
33+ promptCachingEnabled: input.promptCachingEnabled,
34+ openaiPromptCacheRetention: input.openaiPromptCacheRetention,
35+ googleCachedContent: input.googleCachedContent,
36+ toolCount: input.toolCount,
37+ hasSystemPrompt: Boolean(input.systemPrompt),
38+ });
39+
40+ const prepared = prepareTurnMessages({
41+ messages: input.messages,
42+ modelString: input.modelString,
43+ toolCount: input.toolCount,
44+ systemPrompt: input.systemPrompt,
45+ pruningMode: input.pruningMode,
46+ toolResultPayloadCapBytes: input.toolResultPayloadCapBytes,
47+ promptCachingEnabled: input.promptCachingEnabled,
48+ });
49+
50+ return { providerOptionsResult, prepared };
51+}
52+
53+interface BuildStreamTextRequestInput {
54+ model: CoreModel;
55+ prepared: ReturnType<typeof prepareTurnMessages>;
56+ toolSet: ToolSet;
57+ onStepFinish: NonNullable<StreamTextOptions["onStepFinish"]>;
58+ signal: AbortSignal | undefined;
59+ providerOptions: Record<string, unknown>;
60+ maxSteps: number;
61+}
62+
63+export function buildStreamTextRequest(
64+ input: BuildStreamTextRequestInput,
65+): StreamTextOptions {
66+ return {
67+ model: input.model,
68+ messages: input.prepared.messages,
69+ tools: input.toolSet,
70+ stopWhen: stepCountIs(input.maxSteps),
71+ onStepFinish: input.onStepFinish,
72+ prepareStep: ({ stepNumber }: { stepNumber: number }) => {
73+ if (stepNumber >= input.maxSteps - 1) {
74+ return { activeTools: [] as Array<keyof typeof input.toolSet> };
75+ }
76+ return undefined;
77+ },
78+ ...(input.prepared.systemPrompt
79+ ? { system: input.prepared.systemPrompt }
80+ : {}),
81+ ...(Object.keys(input.providerOptions).length > 0
82+ ? {
83+ providerOptions:
84+ input.providerOptions as unknown as StreamTextOptions["providerOptions"],
85+ }
86+ : {}),
87+ ...(input.signal ? { abortSignal: input.signal } : {}),
88+ timeout: { chunkMs: 120_000 },
89+ } as StreamTextOptions;
90+}
src/llm-api/turn.ts+21−36
@@ -1,4 +1,4 @@
1-import { stepCountIs, streamText } from "ai";
1+import { streamText } from "ai";
22 import { isApiLogEnabled, logApiEvent } from "./api-log.ts";
33 import type { ThinkingEffort } from "./provider-options.ts";
44 import {
@@ -11,8 +11,10 @@ import {
1111 mapFullStreamToTurnEvents,
1212 type StreamTextResultFull,
1313 } from "./turn-execution.ts";
14-import { prepareTurnMessages } from "./turn-prepare-messages.ts";
15-import { buildTurnProviderOptions } from "./turn-provider-options.ts";
14+import {
15+ buildStreamTextRequest,
16+ buildTurnPreparation,
17+} from "./turn-request.ts";
1618
1719 export type { ContextPruningMode } from "./turn-context.ts";
1820
@@ -74,14 +76,17 @@ export async function* runTurn(options: {
7476
7577 try {
7678 const toolCount = Object.keys(toolSet).length;
77- const providerOptionsResult = buildTurnProviderOptions({
79+ const { providerOptionsResult, prepared } = buildTurnPreparation({
7880 modelString,
81+ messages,
7982 thinkingEffort,
8083 promptCachingEnabled,
8184 openaiPromptCacheRetention,
8285 googleCachedContent,
8386 toolCount,
84- hasSystemPrompt: Boolean(systemPrompt),
87+ systemPrompt,
88+ pruningMode,
89+ toolResultPayloadCapBytes,
8590 });
8691
8792 logApiEvent("turn start", {
@@ -93,17 +98,6 @@ export async function* runTurn(options: {
9398 toolResultPayloadCapBytes,
9499 });
95100
96- // Prepare messages: sanitize, prune, compact, annotate cache breakpoints
97- const prepared = prepareTurnMessages({
98- messages,
99- modelString,
100- toolCount,
101- systemPrompt,
102- pruningMode,
103- toolResultPayloadCapBytes,
104- promptCachingEnabled,
105- });
106-
107101 if (prepared.pruned) {
108102 yield {
109103 type: "context-pruned",
@@ -127,26 +121,17 @@ export async function* runTurn(options: {
127121 });
128122 }
129123
130- const result = streamText({
131- model,
132- messages: prepared.messages,
133- tools: toolSet,
134- stopWhen: stepCountIs(MAX_STEPS),
135- onStepFinish: stepTracker.onStepFinish,
136- prepareStep: ({ stepNumber }: { stepNumber: number }) => {
137- // On the last allowed step, disable tools so the model gives a final answer
138- if (stepNumber >= MAX_STEPS - 1) {
139- return { activeTools: [] as Array<keyof typeof toolSet> };
140- }
141- return undefined;
142- },
143- ...(prepared.systemPrompt ? { system: prepared.systemPrompt } : {}),
144- ...(Object.keys(providerOptionsResult.providerOptions).length > 0
145- ? { providerOptions: providerOptionsResult.providerOptions }
146- : {}),
147- ...(signal ? { abortSignal: signal } : {}),
148- timeout: { chunkMs: 120_000 },
149- } as StreamTextOptions) as StreamTextResultFull;
124+ const result = streamText(
125+ buildStreamTextRequest({
126+ model,
127+ prepared,
128+ toolSet,
129+ onStepFinish: stepTracker.onStepFinish,
130+ signal,
131+ providerOptions: providerOptionsResult.providerOptions,
132+ maxSteps: MAX_STEPS,
133+ }),
134+ ) as StreamTextResultFull;
150135 result.response.catch(() => {});
151136
152137 for await (const event of mapFullStreamToTurnEvents(result.fullStream, {