repositories / pi-ext

pi-ext

bugabingas pi extensions

owned by bugabinga

extensions/overkill/lib/optimizer.ts

Raw
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<void>;
	subscribe: (listener: (event: OptimizerEvent) => void) => () => void;
	abort: () => Promise<void>;
	dispose: () => void | Promise<void>;
};

export type OptimizerSdkSeam = {
	DefaultResourceLoader: new (
		options: Record<string, unknown>,
	) => { reload: () => Promise<void> };
	SettingsManager: { inMemory: (settings: unknown) => unknown };
	SessionManager: { inMemory: (cwd: string) => unknown };
	createAgentSession: (
		options: Record<string, unknown>,
	) => 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<OptimizerSession> {
	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<unknown> {
	let output: unknown;
	let outputs = 0;
	let abortPromise: Promise<void> | 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<OptimizerSession> },
	signal?: AbortSignal,
	progress: OptimizerReflectionProgress = {},
	onCall?: () => Promise<void>,
	onProgress?: (progress: OptimizerReflectionProgress) => Promise<void>,
): 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());
	}
}