repositories / pi-ext
pi-ext
bugabingas pi extensions
owned by bugabinga
extensions/overkill/lib/optimizer.ts
Rawimport {
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;
},
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,
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();
};
const parsedOutput = async <T>(
text: string,
parse: (value: unknown) => T,
retryInstruction: string,
) => {
let first: unknown;
try {
first = await prompt(text);
} catch (error) {
if (
!(error instanceof Error) ||
error.message !== "optimizer must emit exactly one structured output"
)
throw error;
}
try {
return parse(first);
} catch {
return parse(await prompt(`${text}\nRetry: ${retryInstruction}`));
}
};
const proposal = async (text: string) =>
await parsedOutput(
text,
assertProposal,
"the previous structured output was malformed. Return exactly one proposal string and no edits.",
);
const patch = async (text: string) =>
await parsedOutput(
text,
assertPatch,
"the previous structured output was malformed. Return only one valid patch with one to four atomic edits.",
);
try {
const failure =
options.failures.length === 0
? { proposal: "" }
: progress.failure === undefined
? await proposal(
`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
? await proposal(
`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
? await proposal(
`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 result = await patch(
`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: result, calls };
} finally {
await Promise.resolve(session.dispose());
}
}