textopt 0.0.0

package/dist/random-search/index.cjs

@@ -0,0 +1,321 @@
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+const require_evaluation = require("../evaluation-OZOp6TB7.cjs");
+const require_concurrency = require("../concurrency-C-cFzWW2.cjs");
+const require_text = require("../text-CK_HB3su.cjs");
+//#region src/random-search/optimize.ts
+const DEFAULT_VARIANTS = 4;
+/**
+* The ablation baseline: propose blind, evaluate in full, keep what wins.
+*
+* It exists to be beaten. Reflective search costs a frontier-model call per
+* proposal on top of its rollouts, and running the same budget through a
+* search that cannot read feedback at all puts a floor under what that call
+* has to buy. A GEPA run that does not clear this one is paying for machinery
+* it is not using.
+*
+* What the gap measures is the whole of that machinery, not reflection alone:
+* this drops feedback, Pareto parent selection, and minibatch screening
+* together, and GEPA's own ablations put candidate selection at several points
+* by itself. For reflection in isolation, keep GEPA and hand it a
+* `reflection.buildPrompt` that withholds the evidence — same frontier, same
+* screening, one variable.
+*
+* Not DSPy's `BootstrapFewShotWithRandomSearch`, which the literature usually
+* means by "random search" and which searches bootstrapped demo sets; nor
+* random search in the Bergstra–Bengio sense, since proposals are paraphrases
+* of the incumbent rather than independent draws. No reference implements this
+* baseline — it is original here, and the GEPA paper has no equivalent.
+*/
+var RandomSearchOptimizer = class {
+	#config;
+	constructor(config = {}) {
+		assertConfig(config);
+		this.#config = config;
+	}
+	async optimize(task) {
+		return runRandomSearch({
+			config: this.#config,
+			task
+		});
+	}
+};
+/**
+* Adapted from the GEPA reflection prompt with every source of evidence
+* removed. What is left is the ablation: the same model, the same component,
+* the same output format, and nothing to reason from.
+*/
+function buildParaphrasePrompt(args) {
+	const { componentName, currentText, attempt } = args;
+	return [
+		`Here is the current instruction for the "${componentName}" component of a larger system:`,
+		"",
+		"<current_instruction>",
+		currentText,
+		"</current_instruction>",
+		"",
+		"Write a different instruction for this component.",
+		"You have no information about how the current one has performed, so do not guess at its weaknesses — vary it instead.",
+		`Make variation ${attempt + 1} distinct from the others: change the wording, the level of detail, or the strategy it describes.`,
+		"",
+		"Return only the new instruction, inside a ``` block."
+	].join("\n");
+}
+async function runRandomSearch(args) {
+	const { config, task } = args;
+	const { variants = DEFAULT_VARIANTS, concurrency = 1, maxRounds = Number.POSITIVE_INFINITY, buildPrompt = buildParaphrasePrompt, trackBestOutputs = false, checkpointCache = true } = config;
+	const { seedCandidate, trainingSet, validationSet = trainingSet, testSet, adapter, reflect, maxMetricCalls, cache, cacheNamespace, retry, maxCostUsd, maxWallClockMs, instanceId = defaultInstanceId, onEvent, onCheckpoint, resumeFrom, signal } = task;
+	const deadline = require_evaluation.createDeadline({ maxWallClockMs });
+	const components = require_evaluation.componentNames(seedCandidate);
+	if (trainingSet.length === 0) throw new Error("optimize requires a non-empty trainingSet");
+	if (validationSet.length === 0) throw new Error("optimize requires a non-empty validationSet");
+	if (components.length === 0) throw new Error("optimize requires a seed candidate with at least one component");
+	if (testSet !== void 0 && testSet.length === 0) throw new Error("optimize requires a non-empty testSet when one is given; omit it to skip held-out evaluation");
+	const validationIds = validationSet.map((datum, index) => instanceId({
+		datum,
+		index
+	}));
+	const testIds = testSet?.map((datum, index) => instanceId({
+		datum,
+		index
+	})) ?? [];
+	const fingerprint = require_evaluation.runFingerprint({
+		seedCandidate,
+		trainingIds: trainingSet.map((datum, index) => instanceId({
+			datum,
+			index
+		})),
+		validationIds,
+		...cacheNamespace === void 0 ? {} : { cacheNamespace }
+	});
+	require_evaluation.assertResumable({
+		fingerprint,
+		...resumeFrom === void 0 ? {} : { snapshot: resumeFrom }
+	});
+	const budget = require_evaluation.createBudget({
+		maxMetricCalls,
+		spent: resumeFrom?.metricCalls ?? 0
+	});
+	const evaluationCache = cache === false ? void 0 : cache ?? require_evaluation.createMemoryCache();
+	const evaluator = require_evaluation.createEvaluator({
+		adapter,
+		budget,
+		...retry === void 0 ? {} : { retry },
+		...cacheNamespace === void 0 ? {} : { cacheNamespace },
+		...evaluationCache === void 0 ? {} : { cache: evaluationCache },
+		trackOutputs: trackBestOutputs,
+		cacheHits: resumeFrom?.cacheHits ?? 0,
+		...signal === void 0 ? {} : { signal },
+		onEvaluation: (event) => onEvent?.({
+			type: "evaluation",
+			...event
+		})
+	});
+	evaluator.restore(resumeFrom?.cache ?? []);
+	let round = resumeFrom?.round ?? 0;
+	let variantsEvaluated = resumeFrom?.variantsEvaluated ?? 0;
+	let reflectionCalls = resumeFrom?.reflectionCalls ?? 0;
+	let stopReason = "maxRounds";
+	/**
+	* Consecutive rounds that neither spent a rollout nor improved on the
+	* incumbent. A proposer stuck on texts that are already cached costs
+	* nothing, so neither the metric budget nor the cost ceiling can end the
+	* run — without this the loop spins forever, burning reflection calls that
+	* no budget here bounds.
+	*/
+	let stalledRounds = 0;
+	onEvent?.({
+		type: "start",
+		components,
+		validationSetSize: validationSet.length
+	});
+	async function sweep(args) {
+		return evaluator.evaluate({
+			candidate: args.candidate,
+			batch: validationSet,
+			ids: validationIds,
+			split: "val",
+			phase: args.phase,
+			candidateId: null,
+			iteration: round
+		});
+	}
+	function takeSnapshot() {
+		const cached = checkpointCache ? evaluationCache?.entries?.() : void 0;
+		return {
+			version: 1,
+			fingerprint,
+			best,
+			bestScore,
+			seedScore,
+			round,
+			variantsEvaluated,
+			reflectionCalls,
+			metricCalls: budget.spent(),
+			cacheHits: evaluator.cacheHits(),
+			...cached === void 0 ? {} : { cache: cached }
+		};
+	}
+	async function checkpoint() {
+		if (onCheckpoint === void 0) return;
+		await onCheckpoint(takeSnapshot());
+	}
+	const seedEvaluation = resumeFrom === void 0 ? await sweep({
+		candidate: seedCandidate,
+		phase: "seed"
+	}) : void 0;
+	const seedScore = seedEvaluation === void 0 ? resumeFrom.seedScore : require_evaluation.requireMeasuredMean({
+		batch: seedEvaluation,
+		phase: "seed"
+	});
+	let best = resumeFrom?.best ?? seedCandidate;
+	let bestScore = resumeFrom?.bestScore ?? seedScore;
+	/** Absent on a resumed run until a variant wins: outputs are not checkpointed. */
+	let bestOutputs = seedEvaluation?.outputs;
+	await checkpoint();
+	while (round < maxRounds) {
+		if (signal?.aborted) {
+			stopReason = "aborted";
+			break;
+		}
+		if (require_evaluation.costExhausted({
+			usage: evaluator.usage(),
+			maxCostUsd
+		})) {
+			stopReason = "costExhausted";
+			break;
+		}
+		if (deadline.exceeded()) {
+			stopReason = "deadlineReached";
+			break;
+		}
+		if (!budget.canAfford(variants * validationSet.length)) {
+			stopReason = "budgetExhausted";
+			break;
+		}
+		const component = components[round % components.length];
+		onEvent?.({
+			type: "roundStart",
+			round,
+			component
+		});
+		const spentBefore = budget.spent();
+		const scoreBefore = bestScore;
+		const currentText = best[component];
+		const drawn = await require_concurrency.mapWithConcurrency({
+			items: Array.from({ length: variants }, (_, attempt) => attempt),
+			limit: concurrency,
+			signal,
+			task: async (attempt) => {
+				reflectionCalls += 1;
+				const response = await reflect({
+					prompt: buildPrompt({
+						componentName: component,
+						currentText,
+						attempt
+					}),
+					...signal === void 0 ? {} : { signal }
+				});
+				return require_text.parseProposedText(response);
+			}
+		});
+		const unique = [...new Set(drawn)].filter((text) => text.length > 0 && text !== currentText);
+		let roundStop;
+		for (const text of unique) {
+			const candidate = {
+				...best,
+				[component]: text
+			};
+			let evaluation;
+			try {
+				evaluation = await sweep({
+					candidate,
+					phase: "validation"
+				});
+			} catch (err) {
+				if (err instanceof require_evaluation.BudgetExhausted) {
+					roundStop = "budgetExhausted";
+					break;
+				}
+				if (signal?.aborted) {
+					roundStop = "aborted";
+					break;
+				}
+				throw err;
+			}
+			variantsEvaluated += 1;
+			const score = require_evaluation.measuredMean(evaluation);
+			if (score !== void 0 && score > bestScore) {
+				onEvent?.({
+					type: "candidateAccepted",
+					round,
+					component,
+					score,
+					previousScore: bestScore
+				});
+				best = candidate;
+				bestScore = score;
+				bestOutputs = evaluation.outputs;
+			}
+		}
+		round += 1;
+		stalledRounds = budget.spent() === spentBefore && bestScore === scoreBefore ? stalledRounds + 1 : 0;
+		await checkpoint();
+		if (stalledRounds >= components.length) {
+			stopReason = "proposerStalled";
+			break;
+		}
+		if (roundStop !== void 0) {
+			stopReason = roundStop;
+			break;
+		}
+	}
+	if (signal?.aborted) stopReason = "aborted";
+	const testScore = testSet === void 0 ? void 0 : require_evaluation.measuredMean(await evaluator.evaluate({
+		candidate: best,
+		batch: testSet,
+		ids: testIds,
+		split: "test",
+		phase: "test",
+		candidateId: null,
+		iteration: round,
+		charge: false
+	}));
+	onEvent?.({
+		type: "finish",
+		reason: stopReason,
+		bestScore,
+		metricCalls: budget.spent(),
+		...testScore === void 0 ? {} : { testScore }
+	});
+	return {
+		bestCandidate: best,
+		bestScore,
+		usage: evaluator.usage(),
+		seedScore,
+		snapshot: takeSnapshot(),
+		...trackBestOutputs ? { bestOutputs } : {},
+		...testScore === void 0 ? {} : {
+			testScore,
+			testMetricCalls: evaluator.unchargedCalls()
+		},
+		rounds: round,
+		variantsEvaluated,
+		metricCalls: budget.spent(),
+		reflectionCalls,
+		cacheHits: evaluator.cacheHits(),
+		stopReason
+	};
+}
+function assertConfig(config) {
+	const { variants = DEFAULT_VARIANTS, concurrency = 1, maxRounds } = config;
+	if (!Number.isInteger(variants) || variants < 1) throw new Error(`variants must be a positive integer, received ${variants}`);
+	if (!Number.isInteger(concurrency) || concurrency < 1) throw new Error(`concurrency must be a positive integer, received ${concurrency}`);
+	if (maxRounds !== void 0 && (!Number.isInteger(maxRounds) || maxRounds < 1)) throw new Error(`maxRounds must be a positive integer, received ${maxRounds}`);
+}
+function defaultInstanceId(args) {
+	const hash = require_evaluation.stableHash(args.datum);
+	return hash === "" ? String(args.index) : hash;
+}
+//#endregion
+exports.RandomSearchOptimizer = RandomSearchOptimizer;
+exports.buildParaphrasePrompt = buildParaphrasePrompt;

package/dist/random-search/index.d.cts

@@ -0,0 +1,156 @@
+import { n as Candidate, t as Adapter, u as TextModel } from "../types-CWv4IQFF.cjs";
+import { n as EvaluationCache, t as CachedScore } from "../cache-CuSo0NJ8.cjs";
+import { n as OptimizerResult, r as OptimizerTask, s as EvaluationEvent, t as Optimizer } from "../optimizer-B7SpRwl7.cjs";
+//#region src/random-search/optimize.d.ts
+/** Builds the prompt one variant is drawn from. */
+type ParaphrasePromptBuilder = (args: {
+  componentName: string;
+  currentText: string;
+  /** Which of this round's variants is being drawn, from 0. */
+  attempt: number;
+}) => string;
+/**
+ * How the baseline searches. Deliberately small: every knob GEPA has that this
+ * one lacks is a knob whose value GEPA has to earn.
+ */
+interface RandomSearchConfig {
+  /** Variants drawn per round, each evaluated in full. Default 4. */
+  variants?: number;
+  /** How many of them may be in flight at once. Default 1. */
+  concurrency?: number;
+  maxRounds?: number;
+  /** Replaces the default paraphrase template. */
+  buildPrompt?: ParaphrasePromptBuilder;
+  /** Keep what the winner produced on each validation instance. */
+  trackBestOutputs?: boolean;
+  /**
+   * Include cached instance scores in every checkpoint. Leaving them out keeps
+   * snapshots small at the cost of a resumed run re-paying for rollouts it
+   * cannot look up. Default true.
+   */
+  checkpointCache?: boolean;
+}
+/**
+ * Everything needed to continue a run: the incumbent and its score, the budget
+ * already spent, and the bookkeeping that stops the seed from being re-scored.
+ * Plain JSON — persist it and hand it back as `resumeFrom`.
+ *
+ * There is no random stream here because this search has none: its variants
+ * come from the proposer alone.
+ */
+interface RandomSearchSnapshot {
+  version: 1;
+  /**
+   * Identifies the run this came from — seed candidate, instance ids, cache
+   * namespace. Resuming against a different setup is refused rather than
+   * silently scoring an old incumbent against new data.
+   */
+  fingerprint: string;
+  best: Candidate;
+  bestScore: number;
+  seedScore: number;
+  round: number;
+  variantsEvaluated: number;
+  reflectionCalls: number;
+  metricCalls: number;
+  cacheHits: number;
+  /** Cached instance scores, when the cache can enumerate them. */
+  cache?: [string, CachedScore][];
+}
+interface RandomSearchTask<Datum, Trajectory = unknown, Output = unknown, K extends string = string> extends OptimizerTask<Datum, Trajectory, Output, K> {
+  /**
+   * The base adapter, not `GepaAdapter`: this search never reflects, so it has
+   * no use for a reflective dataset and does not ask for one.
+   */
+  adapter: Adapter<Datum, Trajectory, Output, NoInfer<K>>;
+  /** Rewrites a component's text. Sees the text and nothing else. */
+  reflect: TextModel;
+  instanceId?: (args: {
+    datum: NoInfer<Datum>;
+    index: number;
+  }) => string;
+  /** Pass `false` to disable caching entirely. */
+  cache?: EvaluationCache | false;
+  onEvent?: (event: RandomSearchEvent<NoInfer<K>>) => void;
+  /**
+   * Called with a resumable snapshot after the seed is scored and after every
+   * round. Persist it and a killed run costs the last round, not all of them.
+   */
+  onCheckpoint?: (snapshot: RandomSearchSnapshot) => void | Promise<void>;
+  /** Snapshot to continue from, instead of starting at the seed candidate. */
+  resumeFrom?: RandomSearchSnapshot;
+}
+type RandomSearchStopReason = "budgetExhausted" | "costExhausted" | "deadlineReached" | "maxRounds" | "proposerStalled" | "aborted";
+type RandomSearchEvent<K extends string = string> = {
+  type: "start";
+  components: K[];
+  validationSetSize: number;
+} | {
+  type: "roundStart";
+  round: number;
+  component: K;
+} | ({
+  type: "evaluation";
+} & EvaluationEvent) | {
+  type: "candidateAccepted";
+  round: number;
+  component: K;
+  score: number;
+  previousScore: number;
+} | {
+  type: "finish";
+  reason: RandomSearchStopReason;
+  bestScore: number;
+  metricCalls: number;
+  testScore?: number;
+};
+interface RandomSearchResult<K extends string = string, Output = unknown> extends OptimizerResult<K, RandomSearchStopReason, Output> {
+  /** The seed's score, so the lift the search bought is readable directly. */
+  seedScore: number;
+  rounds: number;
+  /** Variants drawn and evaluated, including the ones that lost. */
+  variantsEvaluated: number;
+  reflectionCalls: number;
+  cacheHits: number;
+  /** State as of the last round, ready to hand back as `resumeFrom`. */
+  snapshot: RandomSearchSnapshot;
+}
+/**
+ * The ablation baseline: propose blind, evaluate in full, keep what wins.
+ *
+ * It exists to be beaten. Reflective search costs a frontier-model call per
+ * proposal on top of its rollouts, and running the same budget through a
+ * search that cannot read feedback at all puts a floor under what that call
+ * has to buy. A GEPA run that does not clear this one is paying for machinery
+ * it is not using.
+ *
+ * What the gap measures is the whole of that machinery, not reflection alone:
+ * this drops feedback, Pareto parent selection, and minibatch screening
+ * together, and GEPA's own ablations put candidate selection at several points
+ * by itself. For reflection in isolation, keep GEPA and hand it a
+ * `reflection.buildPrompt` that withholds the evidence — same frontier, same
+ * screening, one variable.
+ *
+ * Not DSPy's `BootstrapFewShotWithRandomSearch`, which the literature usually
+ * means by "random search" and which searches bootstrapped demo sets; nor
+ * random search in the Bergstra–Bengio sense, since proposals are paraphrases
+ * of the incumbent rather than independent draws. No reference implements this
+ * baseline — it is original here, and the GEPA paper has no equivalent.
+ */
+declare class RandomSearchOptimizer implements Optimizer<RandomSearchStopReason> {
+  #private;
+  constructor(config?: RandomSearchConfig);
+  optimize<Datum, Trajectory = unknown, Output = unknown, const K extends string = string>(task: RandomSearchTask<Datum, Trajectory, Output, K>): Promise<RandomSearchResult<K, Output>>;
+}
+/**
+ * Adapted from the GEPA reflection prompt with every source of evidence
+ * removed. What is left is the ablation: the same model, the same component,
+ * the same output format, and nothing to reason from.
+ */
+declare function buildParaphrasePrompt(args: {
+  componentName: string;
+  currentText: string;
+  attempt: number;
+}): string;
+//#endregion
+export { type ParaphrasePromptBuilder, type RandomSearchConfig, type RandomSearchEvent, RandomSearchOptimizer, type RandomSearchResult, type RandomSearchSnapshot, type RandomSearchStopReason, type RandomSearchTask, buildParaphrasePrompt };

package/dist/random-search/index.d.mts

@@ -0,0 +1,156 @@
+import { n as Candidate, t as Adapter, u as TextModel } from "../types-CWv4IQFF.mjs";
+import { n as EvaluationCache, t as CachedScore } from "../cache-CuSo0NJ8.mjs";
+import { n as OptimizerResult, r as OptimizerTask, s as EvaluationEvent, t as Optimizer } from "../optimizer-DqCoth_w.mjs";
+//#region src/random-search/optimize.d.ts
+/** Builds the prompt one variant is drawn from. */
+type ParaphrasePromptBuilder = (args: {
+  componentName: string;
+  currentText: string;
+  /** Which of this round's variants is being drawn, from 0. */
+  attempt: number;
+}) => string;
+/**
+ * How the baseline searches. Deliberately small: every knob GEPA has that this
+ * one lacks is a knob whose value GEPA has to earn.
+ */
+interface RandomSearchConfig {
+  /** Variants drawn per round, each evaluated in full. Default 4. */
+  variants?: number;
+  /** How many of them may be in flight at once. Default 1. */
+  concurrency?: number;
+  maxRounds?: number;
+  /** Replaces the default paraphrase template. */
+  buildPrompt?: ParaphrasePromptBuilder;
+  /** Keep what the winner produced on each validation instance. */
+  trackBestOutputs?: boolean;
+  /**
+   * Include cached instance scores in every checkpoint. Leaving them out keeps
+   * snapshots small at the cost of a resumed run re-paying for rollouts it
+   * cannot look up. Default true.
+   */
+  checkpointCache?: boolean;
+}
+/**
+ * Everything needed to continue a run: the incumbent and its score, the budget
+ * already spent, and the bookkeeping that stops the seed from being re-scored.
+ * Plain JSON — persist it and hand it back as `resumeFrom`.
+ *
+ * There is no random stream here because this search has none: its variants
+ * come from the proposer alone.
+ */
+interface RandomSearchSnapshot {
+  version: 1;
+  /**
+   * Identifies the run this came from — seed candidate, instance ids, cache
+   * namespace. Resuming against a different setup is refused rather than
+   * silently scoring an old incumbent against new data.
+   */
+  fingerprint: string;
+  best: Candidate;
+  bestScore: number;
+  seedScore: number;
+  round: number;
+  variantsEvaluated: number;
+  reflectionCalls: number;
+  metricCalls: number;
+  cacheHits: number;
+  /** Cached instance scores, when the cache can enumerate them. */
+  cache?: [string, CachedScore][];
+}
+interface RandomSearchTask<Datum, Trajectory = unknown, Output = unknown, K extends string = string> extends OptimizerTask<Datum, Trajectory, Output, K> {
+  /**
+   * The base adapter, not `GepaAdapter`: this search never reflects, so it has
+   * no use for a reflective dataset and does not ask for one.
+   */
+  adapter: Adapter<Datum, Trajectory, Output, NoInfer<K>>;
+  /** Rewrites a component's text. Sees the text and nothing else. */
+  reflect: TextModel;
+  instanceId?: (args: {
+    datum: NoInfer<Datum>;
+    index: number;
+  }) => string;
+  /** Pass `false` to disable caching entirely. */
+  cache?: EvaluationCache | false;
+  onEvent?: (event: RandomSearchEvent<NoInfer<K>>) => void;
+  /**
+   * Called with a resumable snapshot after the seed is scored and after every
+   * round. Persist it and a killed run costs the last round, not all of them.
+   */
+  onCheckpoint?: (snapshot: RandomSearchSnapshot) => void | Promise<void>;
+  /** Snapshot to continue from, instead of starting at the seed candidate. */
+  resumeFrom?: RandomSearchSnapshot;
+}
+type RandomSearchStopReason = "budgetExhausted" | "costExhausted" | "deadlineReached" | "maxRounds" | "proposerStalled" | "aborted";
+type RandomSearchEvent<K extends string = string> = {
+  type: "start";
+  components: K[];
+  validationSetSize: number;
+} | {
+  type: "roundStart";
+  round: number;
+  component: K;
+} | ({
+  type: "evaluation";
+} & EvaluationEvent) | {
+  type: "candidateAccepted";
+  round: number;
+  component: K;
+  score: number;
+  previousScore: number;
+} | {
+  type: "finish";
+  reason: RandomSearchStopReason;
+  bestScore: number;
+  metricCalls: number;
+  testScore?: number;
+};
+interface RandomSearchResult<K extends string = string, Output = unknown> extends OptimizerResult<K, RandomSearchStopReason, Output> {
+  /** The seed's score, so the lift the search bought is readable directly. */
+  seedScore: number;
+  rounds: number;
+  /** Variants drawn and evaluated, including the ones that lost. */
+  variantsEvaluated: number;
+  reflectionCalls: number;
+  cacheHits: number;
+  /** State as of the last round, ready to hand back as `resumeFrom`. */
+  snapshot: RandomSearchSnapshot;
+}
+/**
+ * The ablation baseline: propose blind, evaluate in full, keep what wins.
+ *
+ * It exists to be beaten. Reflective search costs a frontier-model call per
+ * proposal on top of its rollouts, and running the same budget through a
+ * search that cannot read feedback at all puts a floor under what that call
+ * has to buy. A GEPA run that does not clear this one is paying for machinery
+ * it is not using.
+ *
+ * What the gap measures is the whole of that machinery, not reflection alone:
+ * this drops feedback, Pareto parent selection, and minibatch screening
+ * together, and GEPA's own ablations put candidate selection at several points
+ * by itself. For reflection in isolation, keep GEPA and hand it a
+ * `reflection.buildPrompt` that withholds the evidence — same frontier, same
+ * screening, one variable.
+ *
+ * Not DSPy's `BootstrapFewShotWithRandomSearch`, which the literature usually
+ * means by "random search" and which searches bootstrapped demo sets; nor
+ * random search in the Bergstra–Bengio sense, since proposals are paraphrases
+ * of the incumbent rather than independent draws. No reference implements this
+ * baseline — it is original here, and the GEPA paper has no equivalent.
+ */
+declare class RandomSearchOptimizer implements Optimizer<RandomSearchStopReason> {
+  #private;
+  constructor(config?: RandomSearchConfig);
+  optimize<Datum, Trajectory = unknown, Output = unknown, const K extends string = string>(task: RandomSearchTask<Datum, Trajectory, Output, K>): Promise<RandomSearchResult<K, Output>>;
+}
+/**
+ * Adapted from the GEPA reflection prompt with every source of evidence
+ * removed. What is left is the ablation: the same model, the same component,
+ * the same output format, and nothing to reason from.
+ */
+declare function buildParaphrasePrompt(args: {
+  componentName: string;
+  currentText: string;
+  attempt: number;
+}): string;
+//#endregion
+export { type ParaphrasePromptBuilder, type RandomSearchConfig, type RandomSearchEvent, RandomSearchOptimizer, type RandomSearchResult, type RandomSearchSnapshot, type RandomSearchStopReason, type RandomSearchTask, buildParaphrasePrompt };