darwin-agents 0.4.9 → 0.5.0-alpha.2

package/dist/src/core/trace-capture.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"trace-capture.d.ts","sourceRoot":"","sources":["../../../src/core/trace-capture.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA8BG;AAEH,OAAO,KAAK,EACV,cAAc,EAEd,eAAe,EAEhB,MAAM,aAAa,CAAC;AAuBrB,MAAM,WAAW,YAAY;IAC3B;;;;;OAKG;IACH,aAAa,CAAC,EAAE,EAAE,MAAM,EAAE,IAAI,EAAE,MAAM,EAAE,IAAI,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,GAAG,IAAI,CAAC;IAC9E;;;;OAIG;IACH,gBAAgB,CACd,EAAE,EAAE,MAAM,EACV,OAAO,EAAE,SAAS,GAAG,OAAO,EAC5B,IAAI,CAAC,EAAE;QACL,aAAa,CAAC,EAAE,MAAM,CAAC;QACvB,UAAU,CAAC,EAAE,MAAM,CAAC;QACpB,YAAY,CAAC,EAAE,MAAM,CAAC;QACtB,UAAU,CAAC,EAAE,MAAM,CAAC;KACrB,GACA,IAAI,CAAC;IACR,gFAAgF;IAChF,SAAS,IAAI,IAAI,CAAC;IAClB;;;;;;OAMG;IACH,eAAe,IAAI,IAAI,CAAC;IACxB,gFAAgF;IAChF,WAAW,CAAC,MAAM,EAAE,MAAM,EAAE,OAAO,EAAE,MAAM,GAAG,IAAI,CAAC;IACnD;;;;;OAKG;IACH,SAAS,CAAC,KAAK,EAAE,eAAe,GAAG,IAAI,CAAC;IACxC;;;;;OAKG;IACH,QAAQ,IAAI,cAAc,CAAC;CAC5B;AAED,MAAM,WAAW,mBAAmB;IAClC;;;OAGG;IACH,GAAG,CAAC,EAAE,MAAM,MAAM,CAAC;IACnB;;;;OAIG;IACH,SAAS,CAAC,EAAE,CAAC,QAAQ,EAAE,MAAM,KAAK,OAAO,CAAC;CAC3C;AAED;;;;;;;;;;;;;GAaG;AACH,wBAAgB,kBAAkB,CAAC,IAAI,GAAE,mBAAwB,GAAG,YAAY,CAoI/E"}

package/dist/src/core/trace-capture.js

@@ -0,0 +1,183 @@
+/**
+ * Darwin — Execution Trace Capture (v0.5 / A1)
+ *
+ * Pure, transport-agnostic capturer. Knows nothing about Anthropic SDK,
+ * Claude CLI, OpenAI, or any specific runtime — the runtime feeds events,
+ * the capturer aggregates into an ExecutionTrace.
+ *
+ * Three event types map to the three industry-standard span types
+ * (Braintrust + Langfuse + Strands SDK + OTEL GenAI 2026):
+ *   - recordToolUse / recordToolResult  → Tool spans
+ *   - recordTextBlock                    → assistant prose counter (NOT thinking-block)
+ *   - recordError                        → Turn-level errors
+ *   - addTokens                          → aggregated LLM token usage
+ *
+ * Pairing rule: each `recordToolUse(id, ...)` MUST be paired with a later
+ * `recordToolResult(id, ...)` to compute durationMs. Unpaired uses get
+ * `durationMs > 0` (start-to-finalize) and `outcome = 'error'` at
+ * finalize-time with errorClass = 'unpaired_call' so we never silently
+ * drop hanging tools.
+ *
+ * Privacy + size: args are passed through as-is — caller's responsibility
+ * to truncate sensitive values. resultSummary is truncated to 2000 chars
+ * at recordToolResult-time. OTEL note: `gen_ai.tool.call.arguments` is
+ * Opt-In in the GenAI spec; Darwin's "always-capture args" stance is
+ * acceptable for internal use but MUST be documented when traces touch
+ * customer data (V2 will add a Redaction-Layer).
+ *
+ * Backwards-compat: capturer is opt-in. Existing code paths that don't
+ * instantiate it produce DarwinExperiment.trajectory === undefined and
+ * the rest of the system behaves identically to pre-A1.
+ */
+/**
+ * Result-summary cap. Tuned for GEPA-style reflective optimizers
+ * (Phase 2 A2): the reflector reads the summary as context for
+ * "why did this tool produce a bad outcome", so a too-tight cap
+ * truncates the diagnostic signal. 2000 chars holds a typical
+ * JSON-RPC tool response without bloating JSONB.
+ * Bumped from 500 → 2000 after R1 Research review (Gap 3).
+ */
+const MAX_RESULT_SUMMARY_CHARS = 2000;
+const MAX_ERROR_MESSAGE_CHARS = 200;
+/**
+ * Create a fresh trace capturer.
+ *
+ * Usage:
+ * ```ts
+ * const trace = createTraceCapture();
+ * trace.startTurn();
+ * trace.recordToolUse('call_1', 'mcp__nex__search', { query: 'foo' });
+ * trace.recordToolResult('call_1', 'success', { resultSummary: '3 hits' });
+ * trace.recordTextBlock();
+ * trace.addTokens({ inputTokens: 1200, outputTokens: 340 });
+ * const trajectory = trace.finalize();
+ * ```
+ */
+export function createTraceCapture(opts = {}) {
+    const now = opts.now ?? (() => Date.now());
+    const isMcpTool = opts.isMcpTool ?? ((name) => name.startsWith('mcp__'));
+    const capturedAt = new Date(now()).toISOString();
+    const pending = new Map();
+    const completed = [];
+    const errors = [];
+    let textBlockCount = 0;
+    let turnCount = 0;
+    // Token-usage aggregate. Kept as a sparse object — undefined fields
+    // stay undefined (vs 0) so consumers can distinguish "provider didn't
+    // report" from "actually zero tokens".
+    const tokenUsage = {};
+    function currentTurn() {
+        // 1-indexed. If no startTurn() was called yet, treat events as belonging
+        // to turn 1 (defensive — capturer should remain useful even if the
+        // runtime forgets to call startTurn).
+        return turnCount === 0 ? 1 : turnCount;
+    }
+    /** Additive merge of one usage record into the aggregate. */
+    function addToken(field, value) {
+        if (typeof value !== 'number' || !Number.isFinite(value))
+            return;
+        tokenUsage[field] = (tokenUsage[field] ?? 0) + value;
+    }
+    return {
+        recordToolUse(id, tool, args) {
+            // Defensive: if a duplicate id is emitted (rare SDK bug), overwrite
+            // — last-write-wins is preferable to crashing or silently dropping
+            // the new call.
+            pending.set(id, {
+                callId: id,
+                tool,
+                args,
+                startedAtMs: now(),
+                turn: currentTurn(),
+                isMcp: isMcpTool(tool),
+            });
+        },
+        recordToolResult(id, outcome, resultOpts) {
+            const start = pending.get(id);
+            if (!start) {
+                // No matching tool_use — silently drop (some SDKs emit tool_result
+                // for built-ins without a paired tool_use event).
+                return;
+            }
+            pending.delete(id);
+            const call = {
+                id: start.callId,
+                tool: start.tool,
+                outcome,
+                durationMs: Math.max(0, now() - start.startedAtMs),
+                turn: start.turn,
+            };
+            if (start.args !== undefined) {
+                call.args = start.args;
+            }
+            if (resultOpts?.resultSummary !== undefined && resultOpts.resultSummary !== null) {
+                call.resultSummary = resultOpts.resultSummary.slice(0, MAX_RESULT_SUMMARY_CHARS);
+            }
+            if (outcome === 'error') {
+                if (resultOpts?.errorClass) {
+                    call.errorClass = resultOpts.errorClass;
+                }
+                if (resultOpts?.errorMessage) {
+                    call.errorMessage = resultOpts.errorMessage.slice(0, MAX_ERROR_MESSAGE_CHARS);
+                }
+            }
+            if (resultOpts?.retryCount && resultOpts.retryCount > 0) {
+                call.retryCount = resultOpts.retryCount;
+            }
+            completed.push(call);
+        },
+        startTurn() {
+            turnCount++;
+        },
+        recordTextBlock() {
+            textBlockCount++;
+        },
+        recordError(class_, message) {
+            errors.push({
+                class: class_,
+                message: message.slice(0, MAX_ERROR_MESSAGE_CHARS),
+                turn: currentTurn(),
+            });
+        },
+        addTokens(usage) {
+            addToken('inputTokens', usage.inputTokens);
+            addToken('outputTokens', usage.outputTokens);
+            addToken('cacheReadTokens', usage.cacheReadTokens);
+            addToken('cacheCreationTokens', usage.cacheCreationTokens);
+        },
+        finalize() {
+            // Surface unpaired tool calls so silent hangs are visible in the trace.
+            // (E.g. SDK crashes mid-tool, child process dies, timeout escapes us.)
+            for (const [, pendingCall] of pending) {
+                completed.push({
+                    id: pendingCall.callId,
+                    tool: pendingCall.tool,
+                    ...(pendingCall.args !== undefined ? { args: pendingCall.args } : {}),
+                    outcome: 'error',
+                    durationMs: Math.max(0, now() - pendingCall.startedAtMs),
+                    errorClass: 'unpaired_call',
+                    errorMessage: 'tool_use without matching tool_result',
+                    turn: pendingCall.turn,
+                });
+            }
+            pending.clear();
+            const mcpInvocations = completed.filter((c) => isMcpTool(c.tool)).length;
+            const trace = {
+                version: 1,
+                toolCalls: completed,
+                textBlockCount,
+                turnCount: Math.max(turnCount, 1),
+                mcpInvocations,
+                errors,
+                capturedAt,
+            };
+            // Only attach tokenUsage if at least one field was populated —
+            // keeps the JSONB lean for runs against providers without usage data.
+            if (Object.keys(tokenUsage).length > 0) {
+                trace.tokenUsage = { ...tokenUsage };
+            }
+            return trace;
+        },
+    };
+}
+//# sourceMappingURL=trace-capture.js.map

package/dist/src/core/trace-capture.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"trace-capture.js","sourceRoot":"","sources":["../../../src/core/trace-capture.ts"],"names":[],"mappings":"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"}

package/dist/src/evolution/optimizer-gepa.d.ts

@@ -0,0 +1,149 @@
+/**
+ * Darwin — GEPA-Style Reflective Optimizer (Phase 2 A2, S1185).
+ *
+ * Generation-loop wrapper around {@link Reflector} + {@link paretoSelect}
+ * that produces N variants (default 3) per cycle and carries the
+ * non-dominated set forward to the next generation. Opt-in via
+ * `useGepa: true` in the evolution loop config.
+ *
+ * Pipeline per generation:
+ *
+ *   1. Take a parent variant (current prompt or last gen's winner).
+ *   2. Generate N candidate mutations by calling the reflector with
+ *      different sliced feedback (forces variation while keeping each
+ *      mutation principled — not stochastic-only).
+ *   3. Caller scores the candidates against their domain metric(s).
+ *   4. paretoSelect keeps the non-dominated set (≤ maxCarry).
+ *   5. Next generation reflects from the survivors.
+ *
+ * This file orchestrates only the GENERATION step. Scoring lives in
+ * the caller (loop.ts → evaluator) because Darwin's existing
+ * multi-critic pipeline is the authoritative source of variant scores.
+ *
+ * Why this design and not a full GEPA-engine port:
+ *   - Keep the Python lib (`gepa-ai/gepa`) out of our peer-dep graph.
+ *   - Reuse Darwin's existing multi-critic + safety + A/B machinery —
+ *     GepaOptimizer is purely about variant GENERATION + Pareto SELECTION.
+ *   - Smallest-possible-edit reflection is the part that empirically
+ *     matters most (per GEPA papers); the multi-objective search is the
+ *     other part. Together they cover the GEPA value-prop without a
+ *     Python dependency.
+ *
+ * **Inspired by, not lifted from** the official GEPA Python library /
+ * arxiv 2507.19457 paper. Deliberate deviations (R1 Research Finding F1
+ * + F4 + F6, S1185):
+ *   - **N variants per generate() call:** GEPA Algorithm 1 produces 1
+ *     offspring per iteration. We produce N=3-5 per call via three
+ *     `feedbackStrategy` modes (split / replicate / single). This is
+ *     our structural adaptation to TS-callsite ergonomics — call us
+ *     three times to recover the per-iteration GEPA budget.
+ *   - **`feedbackStrategy: "split"` is OUR adaptation** — GEPA paper
+ *     does not partition feedback across offspring. We do it to force
+ *     mutation diversity in a single `Promise.all` batch.
+ *   - **paretoSelect truncation uses scalarised tie-break** — GEPA
+ *     Algorithm 2 samples Pareto candidates proportional to instance
+ *     coverage. We use a simpler weighted-sum tie-break. V0.6 will add
+ *     a `truncationStrategy` option for coverage-proportional +
+ *     NSGA-II crowding-distance.
+ *   - **GEPA+Merge (system-aware crossover from two Pareto-pool
+ *     ancestors, paper Appendix F)** is NOT implemented. +5% reported
+ *     lift in the paper. Backlog for V0.6.
+ *   - **Instance-wise coverage sampling** (paper Algorithm 2) is NOT
+ *     implemented. Backlog for V0.6.
+ *
+ * @example
+ * ```ts
+ * import { GepaOptimizer, DARWIN_DEFAULT_OBJECTIVES } from "darwin-agents";
+ *
+ * const optimizer = new GepaOptimizer(myRunPromptFn);
+ *
+ * // Step 1: generate N variant mutations from feedback
+ * const variants = await optimizer.generate(currentPrompt, feedbacks, {
+ *   numVariants: 3,
+ * });
+ *
+ * // Step 2: score each variant externally (via Darwin's multi-critic
+ * // pipeline or any other evaluator)
+ * const scored = await Promise.all(
+ *   variants.map(async (v) => ({
+ *     ...v,
+ *     metrics: await scoreVariant(v.prompt),
+ *   })),
+ * );
+ *
+ * // Step 3: Pareto-select survivors for the next generation
+ * const survivors = optimizer.nextGeneration(scored, {
+ *   objectives: DARWIN_DEFAULT_OBJECTIVES,
+ *   maxCarry: 3,
+ * });
+ * ```
+ */
+import type { ReflectiveFeedback, RunPromptFn } from "./reflector.js";
+import { type ParetoObjective } from "./pareto.js";
+/** One evaluated variant in a generation. */
+export interface ScoredVariant {
+    /** Variant identifier (e.g. "v3-gen2-cand1"). */
+    id: string;
+    /** Mutated prompt text. */
+    prompt: string;
+    /** Score map keyed by objective name — must include the keys in `objectives`. */
+    metrics: Record<string, number>;
+    /** Optional text feedback collected for the next generation's reflector. */
+    textFeedback?: string;
+}
+/** Options for {@link GepaOptimizer#generate}. */
+export interface GenerateOptions {
+    /** Number of variants per generation. Default 3, clamped to [1, 10]. */
+    numVariants?: number;
+    /**
+     * Strategy for feeding feedback to the N reflector calls:
+     *   - `"split"` (default): split feedback array N ways; each variant
+     *     reflects on a different subset → encourages diversity.
+     *   - `"replicate"`: every variant sees every feedback → encourages
+     *     consistency at the cost of diversity.
+     *   - `"single"`: 1 reflection call, deduplicated to a single variant
+     *     (use when feedback set is tiny).
+     */
+    feedbackStrategy?: "split" | "replicate" | "single";
+}
+/** Options for {@link GepaOptimizer#nextGeneration}. */
+export interface NextGenerationOptions extends GenerateOptions {
+    /**
+     * Pareto objectives over `ScoredVariant.metrics`. Required —
+     * GepaOptimizer is multi-objective by design; if you only have one
+     * objective, use the plain `PromptOptimizer` instead.
+     */
+    objectives: ReadonlyArray<ParetoObjective<Record<string, number>>>;
+    /**
+     * Max variants to keep on the Pareto front. Default 3.
+     */
+    maxCarry?: number;
+}
+export declare class GepaOptimizer {
+    private readonly reflector;
+    constructor(runPrompt: RunPromptFn);
+    /**
+     * Generate N variant mutations from the current prompt + feedback set.
+     * Returns the raw mutated prompts — caller scores them (typically via
+     * the existing multi-critic pipeline) before passing them through
+     * {@link GepaOptimizer#nextGeneration}.
+     */
+    generate(currentPrompt: string, feedbacks: ReadonlyArray<ReflectiveFeedback>, opts?: GenerateOptions): Promise<Array<{
+        id: string;
+        prompt: string;
+    }>>;
+    /**
+     * Given the scored variants of a generation, return the survivors
+     * carried to the next generation (Pareto-front, capped at maxCarry).
+     *
+     * This is a pure-function wrapper around `paretoSelect` exposed on
+     * the optimizer for ergonomic call-site grouping ("generate, score,
+     * nextGeneration"). The actual selection logic lives in `pareto.ts`.
+     */
+    nextGeneration(scored: ReadonlyArray<ScoredVariant>, opts: NextGenerationOptions): ScoredVariant[];
+    /** Clamp variant count into the documented bounds. */
+    private clampN;
+    /** Stable variant id: `gepa-cand-${i}` (caller can re-namespace). */
+    private makeId;
+}
+//# sourceMappingURL=optimizer-gepa.d.ts.map

package/dist/src/evolution/optimizer-gepa.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"optimizer-gepa.d.ts","sourceRoot":"","sources":["../../../src/evolution/optimizer-gepa.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA+EG;AAEH,OAAO,KAAK,EAAE,kBAAkB,EAAE,WAAW,EAAE,MAAM,gBAAgB,CAAC;AAEtE,OAAO,EAEL,KAAK,eAAe,EACrB,MAAM,aAAa,CAAC;AAErB,6CAA6C;AAC7C,MAAM,WAAW,aAAa;IAC5B,iDAAiD;IACjD,EAAE,EAAE,MAAM,CAAC;IACX,2BAA2B;IAC3B,MAAM,EAAE,MAAM,CAAC;IACf,iFAAiF;IACjF,OAAO,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC;IAChC,4EAA4E;IAC5E,YAAY,CAAC,EAAE,MAAM,CAAC;CACvB;AAED,kDAAkD;AAClD,MAAM,WAAW,eAAe;IAC9B,wEAAwE;IACxE,WAAW,CAAC,EAAE,MAAM,CAAC;IACrB;;;;;;;;OAQG;IACH,gBAAgB,CAAC,EAAE,OAAO,GAAG,WAAW,GAAG,QAAQ,CAAC;CACrD;AAED,wDAAwD;AACxD,MAAM,WAAW,qBAAsB,SAAQ,eAAe;IAC5D;;;;OAIG;IACH,UAAU,EAAE,aAAa,CAAC,eAAe,CAAC,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC,CAAC,CAAC;IACnE;;OAEG;IACH,QAAQ,CAAC,EAAE,MAAM,CAAC;CACnB;AAOD,qBAAa,aAAa;IACxB,OAAO,CAAC,QAAQ,CAAC,SAAS,CAAY;gBAE1B,SAAS,EAAE,WAAW;IAIlC;;;;;OAKG;IACG,QAAQ,CACZ,aAAa,EAAE,MAAM,EACrB,SAAS,EAAE,aAAa,CAAC,kBAAkB,CAAC,EAC5C,IAAI,GAAE,eAAoB,GACzB,OAAO,CAAC,KAAK,CAAC;QAAE,EAAE,EAAE,MAAM,CAAC;QAAC,MAAM,EAAE,MAAM,CAAA;KAAE,CAAC,CAAC;IA0DjD;;;;;;;OAOG;IACH,cAAc,CACZ,MAAM,EAAE,aAAa,CAAC,aAAa,CAAC,EACpC,IAAI,EAAE,qBAAqB,GAC1B,aAAa,EAAE;IAyClB,sDAAsD;IACtD,OAAO,CAAC,MAAM;IAKd,qEAAqE;IACrE,OAAO,CAAC,MAAM;CAGf"}

package/dist/src/evolution/optimizer-gepa.js

@@ -0,0 +1,198 @@
+/**
+ * Darwin — GEPA-Style Reflective Optimizer (Phase 2 A2, S1185).
+ *
+ * Generation-loop wrapper around {@link Reflector} + {@link paretoSelect}
+ * that produces N variants (default 3) per cycle and carries the
+ * non-dominated set forward to the next generation. Opt-in via
+ * `useGepa: true` in the evolution loop config.
+ *
+ * Pipeline per generation:
+ *
+ *   1. Take a parent variant (current prompt or last gen's winner).
+ *   2. Generate N candidate mutations by calling the reflector with
+ *      different sliced feedback (forces variation while keeping each
+ *      mutation principled — not stochastic-only).
+ *   3. Caller scores the candidates against their domain metric(s).
+ *   4. paretoSelect keeps the non-dominated set (≤ maxCarry).
+ *   5. Next generation reflects from the survivors.
+ *
+ * This file orchestrates only the GENERATION step. Scoring lives in
+ * the caller (loop.ts → evaluator) because Darwin's existing
+ * multi-critic pipeline is the authoritative source of variant scores.
+ *
+ * Why this design and not a full GEPA-engine port:
+ *   - Keep the Python lib (`gepa-ai/gepa`) out of our peer-dep graph.
+ *   - Reuse Darwin's existing multi-critic + safety + A/B machinery —
+ *     GepaOptimizer is purely about variant GENERATION + Pareto SELECTION.
+ *   - Smallest-possible-edit reflection is the part that empirically
+ *     matters most (per GEPA papers); the multi-objective search is the
+ *     other part. Together they cover the GEPA value-prop without a
+ *     Python dependency.
+ *
+ * **Inspired by, not lifted from** the official GEPA Python library /
+ * arxiv 2507.19457 paper. Deliberate deviations (R1 Research Finding F1
+ * + F4 + F6, S1185):
+ *   - **N variants per generate() call:** GEPA Algorithm 1 produces 1
+ *     offspring per iteration. We produce N=3-5 per call via three
+ *     `feedbackStrategy` modes (split / replicate / single). This is
+ *     our structural adaptation to TS-callsite ergonomics — call us
+ *     three times to recover the per-iteration GEPA budget.
+ *   - **`feedbackStrategy: "split"` is OUR adaptation** — GEPA paper
+ *     does not partition feedback across offspring. We do it to force
+ *     mutation diversity in a single `Promise.all` batch.
+ *   - **paretoSelect truncation uses scalarised tie-break** — GEPA
+ *     Algorithm 2 samples Pareto candidates proportional to instance
+ *     coverage. We use a simpler weighted-sum tie-break. V0.6 will add
+ *     a `truncationStrategy` option for coverage-proportional +
+ *     NSGA-II crowding-distance.
+ *   - **GEPA+Merge (system-aware crossover from two Pareto-pool
+ *     ancestors, paper Appendix F)** is NOT implemented. +5% reported
+ *     lift in the paper. Backlog for V0.6.
+ *   - **Instance-wise coverage sampling** (paper Algorithm 2) is NOT
+ *     implemented. Backlog for V0.6.
+ *
+ * @example
+ * ```ts
+ * import { GepaOptimizer, DARWIN_DEFAULT_OBJECTIVES } from "darwin-agents";
+ *
+ * const optimizer = new GepaOptimizer(myRunPromptFn);
+ *
+ * // Step 1: generate N variant mutations from feedback
+ * const variants = await optimizer.generate(currentPrompt, feedbacks, {
+ *   numVariants: 3,
+ * });
+ *
+ * // Step 2: score each variant externally (via Darwin's multi-critic
+ * // pipeline or any other evaluator)
+ * const scored = await Promise.all(
+ *   variants.map(async (v) => ({
+ *     ...v,
+ *     metrics: await scoreVariant(v.prompt),
+ *   })),
+ * );
+ *
+ * // Step 3: Pareto-select survivors for the next generation
+ * const survivors = optimizer.nextGeneration(scored, {
+ *   objectives: DARWIN_DEFAULT_OBJECTIVES,
+ *   maxCarry: 3,
+ * });
+ * ```
+ */
+import { Reflector } from "./reflector.js";
+import { paretoSelect, } from "./pareto.js";
+const DEFAULT_NUM_VARIANTS = 3;
+const MIN_NUM_VARIANTS = 1;
+const MAX_NUM_VARIANTS = 10;
+const DEFAULT_MAX_CARRY = 3;
+export class GepaOptimizer {
+    reflector;
+    constructor(runPrompt) {
+        this.reflector = new Reflector(runPrompt);
+    }
+    /**
+     * Generate N variant mutations from the current prompt + feedback set.
+     * Returns the raw mutated prompts — caller scores them (typically via
+     * the existing multi-critic pipeline) before passing them through
+     * {@link GepaOptimizer#nextGeneration}.
+     */
+    async generate(currentPrompt, feedbacks, opts = {}) {
+        // R2 V0.5.0-alpha.2 Critic Finding R2-L1 (S1185): boundary-level
+        // validation with a GEPA-specific error message. Without this, a
+        // caller passing an empty `feedbacks` array gets an opaque
+        // `Reflector.reflect: feedbacks must contain at least one entry`
+        // bubbling up from internal code.
+        if (feedbacks.length === 0) {
+            throw new TypeError("GepaOptimizer.generate: feedbacks array must be non-empty — " +
+                "GEPA reflection needs at least one variant evaluation to mutate from. " +
+                "Use the plain PromptOptimizer for cold-start mutation.");
+        }
+        const n = this.clampN(opts.numVariants ?? DEFAULT_NUM_VARIANTS);
+        const strategy = opts.feedbackStrategy ?? "split";
+        if (strategy === "single") {
+            // Fast path: one reflection, one variant. Used when feedback set is
+            // small or the caller deliberately wants a single deterministic mutation.
+            const mutated = await this.reflector.reflect(currentPrompt, feedbacks);
+            return [{ id: this.makeId(0), prompt: mutated }];
+        }
+        if (strategy === "replicate") {
+            // Every variant sees every feedback. The LLM is non-deterministic
+            // enough that this still yields N different mutations in practice;
+            // for tests with a deterministic mock you'll get N identical
+            // outputs which is the expected behaviour (and the test asserts
+            // exactly that).
+            const promises = Array.from({ length: n }, () => this.reflector.reflect(currentPrompt, feedbacks));
+            const mutations = await Promise.all(promises);
+            return mutations.map((p, i) => ({ id: this.makeId(i), prompt: p }));
+        }
+        // Default strategy "split": partition feedback round-robin into N
+        // buckets. Each bucket reflects on a different feedback subset.
+        const buckets = Array.from({ length: n }, () => []);
+        feedbacks.forEach((fb, i) => {
+            const bucketIdx = i % n;
+            // Non-null assertion: `n` is clamped to [MIN, MAX] (both ≥ 1) so
+            // every index into a freshly allocated length-n array is in-range.
+            buckets[bucketIdx].push(fb);
+        });
+        const promises = buckets.map((bucket) => {
+            if (bucket.length === 0) {
+                // Bucket is empty (fewer feedbacks than variants) — reflect on
+                // the full set for this slot. Better than skipping the slot.
+                return this.reflector.reflect(currentPrompt, feedbacks);
+            }
+            return this.reflector.reflect(currentPrompt, bucket);
+        });
+        const mutations = await Promise.all(promises);
+        return mutations.map((p, i) => ({ id: this.makeId(i), prompt: p }));
+    }
+    /**
+     * Given the scored variants of a generation, return the survivors
+     * carried to the next generation (Pareto-front, capped at maxCarry).
+     *
+     * This is a pure-function wrapper around `paretoSelect` exposed on
+     * the optimizer for ergonomic call-site grouping ("generate, score,
+     * nextGeneration"). The actual selection logic lives in `pareto.ts`.
+     */
+    nextGeneration(scored, opts) {
+        if (!opts.objectives || opts.objectives.length === 0) {
+            throw new TypeError("GepaOptimizer.nextGeneration: opts.objectives must contain at least one objective");
+        }
+        const maxCarry = opts.maxCarry ?? DEFAULT_MAX_CARRY;
+        // R1 V0.5.0-alpha.2 Critic Finding M2 (S1185): map metrics back to
+        // indices via parallel array (NOT reference-identity on the metrics
+        // object). Reference-identity worked today because paretoSelect
+        // returns the input references, but that is a fragile invariant —
+        // a future refactor to immutable-copy semantics would silently
+        // produce empty survivor sets. Index-based mapping is explicit.
+        //
+        // R2 V0.5.0-alpha.2 Critic Finding R2-M1 (S1185): guard against
+        // shared metrics-object references across ScoredVariants.
+        // Caller-side mistake (programmer reuses the same metrics literal)
+        // would otherwise drop survivors silently in the Map below.
+        const metricsArr = scored.map((v) => v.metrics);
+        if (new Set(metricsArr).size !== metricsArr.length) {
+            throw new TypeError("GepaOptimizer.nextGeneration: two or more ScoredVariants share the same " +
+                "`metrics` object reference — provide a distinct metrics object per variant.");
+        }
+        const objectives = opts.objectives;
+        const survivorMetrics = paretoSelect(metricsArr, objectives, maxCarry);
+        // Build "metrics-ref → index" map then look up each survivor's index.
+        // Linear scan twice is O(N²) worst-case but N≤10 in practice.
+        const metricsToIndex = new Map();
+        metricsArr.forEach((m, i) => metricsToIndex.set(m, i));
+        const survivorIndices = new Set(survivorMetrics
+            .map((m) => metricsToIndex.get(m))
+            .filter((i) => typeof i === "number"));
+        return scored.filter((_, i) => survivorIndices.has(i));
+    }
+    /** Clamp variant count into the documented bounds. */
+    clampN(n) {
+        if (!Number.isFinite(n))
+            return DEFAULT_NUM_VARIANTS;
+        return Math.max(MIN_NUM_VARIANTS, Math.min(MAX_NUM_VARIANTS, Math.floor(n)));
+    }
+    /** Stable variant id: `gepa-cand-${i}` (caller can re-namespace). */
+    makeId(i) {
+        return `gepa-cand-${i}`;
+    }
+}
+//# sourceMappingURL=optimizer-gepa.js.map

package/dist/src/evolution/optimizer-gepa.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"optimizer-gepa.js","sourceRoot":"","sources":["../../../src/evolution/optimizer-gepa.ts"],"names":[],"mappings":"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"}