import { createAgentSession, DefaultResourceLoader, defineTool, SessionManager, SettingsManager, } from "@earendil-works/pi-coding-agent"; import { Type } from "typebox"; import { truncateUtf8 } from "./checker.ts"; import { type Patch, parsePatch } from "./patches.ts"; import type { OptimizerReflectionProgress } from "./training.ts"; type FrozenModel = { provider: string; id: string; thinking: string }; type OptimizerEvent = { type: string; toolName?: string; result?: { details?: unknown }; isError?: boolean; }; export type OptimizerSession = { prompt: ( text: string, options?: { expandPromptTemplates?: boolean }, ) => Promise; subscribe: (listener: (event: OptimizerEvent) => void) => () => void; abort: () => Promise; dispose: () => void | Promise; }; export type OptimizerSdkSeam = { DefaultResourceLoader: new ( options: Record, ) => { reload: () => Promise }; SettingsManager: { inMemory: (settings: unknown) => unknown }; SessionManager: { inMemory: (cwd: string) => unknown }; createAgentSession: ( options: Record, ) => Promise<{ session: OptimizerSession }>; }; export const defaultOptimizerSdk: OptimizerSdkSeam = { DefaultResourceLoader: DefaultResourceLoader as unknown as OptimizerSdkSeam["DefaultResourceLoader"], SettingsManager: SettingsManager as unknown as OptimizerSdkSeam["SettingsManager"], SessionManager: SessionManager as unknown as OptimizerSdkSeam["SessionManager"], createAgentSession: createAgentSession as unknown as OptimizerSdkSeam["createAgentSession"], }; const structuredOutput = defineTool({ name: "structured_output", label: "Structured output", description: "Return the requested structured optimizer result as your final action.", promptSnippet: "Return the requested structured optimizer result.", promptGuidelines: [ "Call structured_output exactly once as the final action.", ], parameters: Type.Object( { proposal: Type.Optional(Type.String()), edits: Type.Optional( Type.Array( Type.Object( { op: Type.String(), target: Type.Optional(Type.String()), content: Type.Optional(Type.String()), }, { additionalProperties: false }, ), ), ), }, { additionalProperties: false }, ), async execute(_toolCallId, params) { return { content: [ { type: "text" as const, text: "Structured optimizer result received.", }, ], details: params, terminate: true, }; }, }); export async function createOptimizerSession( options: { cwd: string; agentDir: string; model: FrozenModel; targetModel: unknown; modelRegistry: unknown; }, sdk: OptimizerSdkSeam = defaultOptimizerSdk, ): Promise { const settingsManager = sdk.SettingsManager.inMemory({ compaction: { enabled: false }, retry: { enabled: false }, }); const loader = new sdk.DefaultResourceLoader({ cwd: options.cwd, agentDir: options.agentDir, settingsManager, noExtensions: true, noSkills: true, noPromptTemplates: true, noThemes: true, noContextFiles: true, }); await loader.reload(); const result = await sdk.createAgentSession({ cwd: options.cwd, agentDir: options.agentDir, model: options.targetModel, modelRegistry: options.modelRegistry, thinkingLevel: options.model.thinking, tools: ["structured_output"], customTools: [structuredOutput], sessionManager: sdk.SessionManager.inMemory(options.cwd), settingsManager, resourceLoader: loader, }); return result.session; } export class OptimizerCancelledError extends Error { constructor() { super("optimizer cancelled"); } } type Proposal = { proposal: string }; function boundedJson(value: unknown, maximumBytes: number): string { return truncateUtf8(JSON.stringify(value), maximumBytes); } function rankingContext(options: { body: string; proposal: string; rejections: readonly unknown[]; }): string { // Reserve space for every required input: a large allowed candidate must not // erase the proposal or rejection feedback that governs the next edit. return `{"body":${JSON.stringify(truncateUtf8(options.body, 32 * 1024))},"proposal":${JSON.stringify(truncateUtf8(options.proposal, 16 * 1024))},"rejections":${boundedJson(options.rejections.slice(-8), 12 * 1024)}}`; } function assertProposal(value: unknown): Proposal { if ( typeof value !== "object" || value === null || Array.isArray(value) || Object.keys(value).length !== 1 || typeof (value as { proposal?: unknown }).proposal !== "string" ) throw new Error("optimizer structured output must be an exact proposal"); return { proposal: (value as { proposal: string }).proposal }; } function assertPatch(value: unknown): Patch { return parsePatch(value); } async function promptForOutput( session: OptimizerSession, prompt: string, signal: AbortSignal | undefined, ): Promise { let output: unknown; let outputs = 0; let abortPromise: Promise | undefined; const abort = () => { abortPromise ??= session.abort(); return abortPromise; }; const unsubscribe = session.subscribe((event) => { if ( event.type !== "tool_execution_end" || event.toolName !== "structured_output" ) return; if (event.isError) return; outputs += 1; output = event.result?.details; }); const onAbort = () => { void abort(); }; signal?.addEventListener("abort", onAbort, { once: true }); try { if (signal?.aborted) { await abort(); throw new OptimizerCancelledError(); } await session.prompt(prompt, { expandPromptTemplates: false }); if (signal?.aborted) { await abort(); throw new OptimizerCancelledError(); } if (outputs !== 1 || output === undefined) throw new Error("optimizer must emit exactly one structured output"); return output; } finally { signal?.removeEventListener("abort", onAbort); unsubscribe(); } } export async function runOptimizerStep( options: { body: string; failures: readonly unknown[]; successes: readonly unknown[]; rejections: readonly unknown[]; }, seam: { createSession: () => Promise }, signal?: AbortSignal, progress: OptimizerReflectionProgress = {}, onCall?: () => Promise, onProgress?: (progress: OptimizerReflectionProgress) => Promise, ): Promise<{ patch: Patch; calls: number }> { const session = await seam.createSession(); let calls = 0; const ensureNotCancelled = () => { if (signal?.aborted) throw new OptimizerCancelledError(); }; const prompt = async (text: string) => { if (signal?.aborted) { await session.abort(); throw new OptimizerCancelledError(); } calls += 1; await onCall?.(); ensureNotCancelled(); return await promptForOutput(session, text, signal); }; const saveProgress = async (next: OptimizerReflectionProgress) => { progress = next; await onProgress?.(progress); ensureNotCancelled(); }; try { const failure = options.failures.length === 0 ? { proposal: "" } : progress.failure === undefined ? assertProposal( await prompt( `phase:failure\nReflect on failed trajectories. Identify root causes and concrete body changes; do not emit a patch.\nfailures:${boundedJson(options.failures, 32 * 1024)}`, ), ) : { proposal: progress.failure }; if (options.failures.length > 0 && progress.failure === undefined) await saveProgress({ ...progress, failure: failure.proposal }); const success = options.successes.length === 0 ? { proposal: "" } : progress.success === undefined ? assertProposal( await prompt( `phase:success\nReflect on successful trajectories and constraints that changes must preserve; do not emit a patch.\nsuccesses:${boundedJson(options.successes, 32 * 1024)}`, ), ) : { proposal: progress.success }; if (options.successes.length > 0 && progress.success === undefined) await saveProgress({ ...progress, success: success.proposal }); const merged = progress.merged === undefined ? assertProposal( await prompt( `phase:merge\nMerge proposals, prioritizing failure fixes while preserving success constraints. Return one concise proposal, not a patch.\ncontext:${boundedJson({ failure, success }, 32 * 1024)}`, ), ) : { proposal: progress.merged }; if (progress.merged === undefined) await saveProgress({ ...progress, merged: merged.proposal }); const patch = assertPatch( await prompt( `phase:ranking\nRank concrete edits for expected validation improvement, avoid prior rejections, then call structured_output exactly once with patch JSON {"edits":[{"op":"append"|"insert_after"|"replace"|"delete","target"?:string,"content"?:string}]}. Use one to four atomic edits.\ncontext:${rankingContext({ body: options.body, proposal: merged.proposal, rejections: options.rejections })}`, ), ); return { patch, calls }; } finally { await Promise.resolve(session.dispose()); } }