@tangle-network/agent-eval 0.144.11 → 0.144.13

package/dist/skillopt-optimization-method-C5cotF4E.d.ts

@@ -0,0 +1,427 @@
+import { c as CostLedgerHandle } from "./cost-ledger-DbQdN3nO.js";
+import { a as RunRecord } from "./run-record-CKiihE6f.js";
+import { E as LlmCallMetadata, p as ChatClient } from "./types-Cx3YUh2r.js";
+import { _ as ExternalTextEvaluationRequest, c as ExternalOptimizerModelBudget, g as ExternalTextCandidate, h as ExternalOptimizerRunnerCommand, l as ExternalOptimizerModelCall, m as ExternalOptimizerResumeMode, r as ExternalOptimizerCallbackLimits } from "./external-optimizer-contracts-lixrOZdX.js";
+import { R as Scenario, S as JudgeConfig, i as CampaignCostMeter, j as MutableSurface, o as CampaignScenarioIdentity, p as Gate } from "./types-BZ59Ahr8.js";
+import { Q as OptimizationPackageSource, W as OptimizationMethod, k as RedTeamCase, z as CanaryOptions } from "./provenance-CCdxgLDT.js";
+import { t as DetectRewardHackingInput } from "./reward-hacking-DSSTuI9r.js";
+//#region src/reference-equivalence-judge.d.ts
+declare const REFERENCE_EQUIVALENCE_JUDGE_VERSION = "reference-equivalence-judge-v1-2026-07-13";
+declare const REFERENCE_EQUIVALENCE_INPUT_LIMITS: {
+  readonly userRequest: 8000;
+  readonly expectedAnswer: 32000;
+  readonly candidateOutput: 32000;
+};
+interface ReferenceEquivalenceScenario extends Scenario {
+  userRequest: string;
+  expectedAnswer: string;
+}
+interface ReferenceEquivalenceJudgeInput {
+  userRequest: string;
+  expectedAnswer: string;
+  candidateOutput: string;
+}
+interface ReferenceEquivalenceJudgeOptions {
+  /** Injected transport. No implicit provider or credentials are selected. */
+  chat: ChatClient;
+  /** Falls back to the ChatClient's default model. */
+  model?: string;
+  /** Used only by the direct-call adapter. */
+  signal?: AbortSignal;
+  /** Optional receipt destination for direct calls; campaigns supply their own. */
+  costLedger?: CostLedgerHandle;
+}
+interface ReferenceEquivalenceJudgeResult extends LlmCallMetadata {
+  kind: 'reference-equivalence';
+  version: string;
+  score: number;
+  rationale: string;
+}
+/** Build the campaign-native expected-answer judge. */
+declare function createReferenceEquivalenceJudge(options: ReferenceEquivalenceJudgeOptions): JudgeConfig<string, ReferenceEquivalenceScenario>;
+/** Direct-call adapter over the campaign judge for product callers. */
+declare function runReferenceEquivalenceJudge(input: ReferenceEquivalenceJudgeInput, options: ReferenceEquivalenceJudgeOptions): Promise<ReferenceEquivalenceJudgeResult>;
+//#endregion
+//#region src/campaign/coverage.d.ts
+/** Reject campaign designs whose denominator cannot be identified exactly. */
+declare function assertCampaignDesign<TScenario extends Scenario>(scenarios: readonly TScenario[], reps: number): void;
+/** Redacted but independently verifiable identity of one complete scenario. */
+declare function campaignScenarioIdentity<TScenario extends Scenario>(scenario: TScenario): CampaignScenarioIdentity & Pick<TScenario, 'id' | 'kind'>;
+/** Canonical split identity reconstructed from redacted scenario identities. */
+declare function campaignSplitDigestFromIdentities(scenarios: readonly CampaignScenarioIdentity[], reps: number): `sha256:${string}`;
+/** Canonical identity of the exact scenario payloads and replicate count. */
+declare function campaignSplitDigest<TScenario extends Scenario>(scenarios: readonly TScenario[], reps: number): `sha256:${string}`;
+/** Refuse a campaign whose retained task identities contradict its split digest. */
+declare function assertCampaignSplitIdentity(scenarios: readonly CampaignScenarioIdentity[], reps: number, splitDigest: string): void;
+//#endregion
+//#region src/campaign/external-text-evaluation.d.ts
+interface ExternalOptimizationExample {
+  id: string;
+  data: unknown;
+}
+interface ExternalTextEvaluationResponse {
+  score: number;
+  info: {
+    scenarioId: string;
+    dimensions: Record<string, number>;
+    notes?: string;
+    artifact?: unknown;
+  };
+}
+declare function decodeExternalTextCandidate(candidate: ExternalTextCandidate): MutableSurface;
+//#endregion
+//#region src/campaign/external-text-optimization-contract.d.ts
+interface ExternalTextOptimizerContext {
+  readonly runId: string;
+  readonly name: string;
+  readonly objective: string;
+  readonly evaluationId: string;
+  readonly background?: string;
+  readonly seedCandidate: ExternalTextCandidate;
+  readonly trainSet: readonly ExternalOptimizationExample[];
+  readonly selectionSet: readonly ExternalOptimizationExample[];
+  readonly maxEvaluations: number;
+  readonly seed: number;
+  /** Stable directory for optimizer checkpoints from compatible attempts. */
+  readonly stateDir: string;
+  readonly restoreRequested: boolean;
+  readonly artifactDir: string;
+  readonly signal: AbortSignal;
+  /** Record every optimizer-owned paid call through this attributed account. */
+  readonly cost: CampaignCostMeter;
+  readonly evaluate: (request: ExternalTextEvaluationRequest) => Promise<ExternalTextEvaluationResponse>;
+}
+interface ExternalTextOptimizerResult {
+  bestCandidate: ExternalTextCandidate;
+  resumed: boolean;
+  costAccounting: {
+    kind: 'metered';
+  } | {
+    kind: 'no-paid-work';
+  } | {
+    kind: 'external';
+    reason: string;
+  };
+}
+/**
+ * Configuration for adapting another text optimizer.
+ *
+ * `run` owns search. Agent Eval owns split isolation, bounded candidate
+ * evaluation, exact cost collection, provenance, and final comparison.
+ */
+interface ExternalTextOptimizationMethodConfig<TScenario extends Scenario, TArtifact = unknown> {
+  name: string;
+  source: Omit<OptimizationPackageSource, 'evidence'>;
+  objective: string;
+  evaluationId: string;
+  background?: string;
+  maxEvaluations: number;
+  /** Hard limit for calls made through `context.cost`. Use 0 for no paid work. */
+  maxOptimizerCostUsd: number;
+  /** Abort `context.signal` after this duration. Default: 30 minutes. */
+  timeoutMs?: number;
+  /** Default: `never`. Compatible runs reuse one state directory. */
+  resume?: ExternalOptimizerResumeMode;
+  maxCandidateChars?: number;
+  maxEvidenceChars?: number;
+  describeScenario?: (scenario: TScenario) => unknown;
+  describeArtifact?: (artifact: TArtifact, scenario: TScenario) => unknown;
+  run: (context: ExternalTextOptimizerContext) => Promise<ExternalTextOptimizerResult>;
+}
+//#endregion
+//#region src/campaign/external-text-optimization.d.ts
+/**
+ * Adapt a third-party text optimizer without reimplementing its search.
+ *
+ * The callback never receives final test cases. Calls to `evaluate` are
+ * counted before execution and stop at `maxEvaluations`.
+ */
+declare function externalTextOptimizationMethod<TScenario extends Scenario, TArtifact>(config: ExternalTextOptimizationMethodConfig<TScenario, TArtifact>): OptimizationMethod<TScenario, TArtifact>;
+//#endregion
+//#region src/campaign/gates/compose.d.ts
+/** Compose gates — all must `ship` for the composite to `ship`. First
+ *  non-ship verdict short-circuits the composite verdict, but ALL gates run
+ *  (so the result records every gate's reason — useful for diagnostics). */
+declare function composeGate<TArtifact = unknown, TScenario extends Scenario = Scenario>(...gates: Array<Gate<TArtifact, TScenario>>): Gate<TArtifact, TScenario>;
+//#endregion
+//#region src/campaign/gates/default-production-gate.d.ts
+type DefaultProductionGateCheck = 'dimension-regression' | 'budget' | 'red-team' | 'reward-hacking' | 'canary';
+type DefaultProductionRewardHackingOptions = Omit<DetectRewardHackingInput, 'runs' | 'truthOf'> & {
+  truthOf: NonNullable<DetectRewardHackingInput['truthOf']>;
+};
+interface DefaultProductionGateOptions {
+  /** Required: scenarios held out from training; substrate compares
+   *  candidate-on-holdout vs baseline-on-holdout. */
+  holdoutScenarios: Scenario[];
+  /** Minimum held-out lift the **paired-bootstrap CI lower bound** must clear
+   *  to ship — NOT a point estimate. Default 0 ⇒ "confidently positive at the
+   *  confidence level". Interpreted in the judge's native composite scale (set
+   *  e.g. 2 for a 0-100 rubric to require a ≥2-point significant gain). */
+  deltaThreshold?: number;
+  /** Confidence level for the held-out + dimension bootstraps. Default 0.95. */
+  confidence?: number;
+  /** Bootstrap resamples. Default 2000. */
+  bootstrapResamples?: number;
+  /** Fixed bootstrap seed for a deterministic verdict. Default 1337. */
+  bootstrapSeed?: number;
+  /** Minimum paired holdout observations (scenarios × reps) before a
+   *  significance claim is allowed. The exact small-sample test may require
+   *  more observations at the selected confidence. Default 3. */
+  minProductiveRuns?: number;
+  /** Ship statistic for the held-out significance test. Default `'mean'`
+   *  (tie-robust — see `heldoutSignificance`). Pass `'median'` for
+   *  outlier-robustness at the cost of tie-blindness. */
+  heldoutStatistic?: 'mean' | 'median';
+  /** Critical judge dimensions that must NOT significantly regress even when
+   *  the net composite rises (anti-Goodhart). The gate HOLDS if any listed
+   *  dimension's paired-delta CI lower bound < −`regressionTolerance`. E.g.
+   *  `['hallucination_free']` for a legal agent. */
+  criticalDimensions?: string[];
+  /** Tolerance for the per-dimension regression guard, in the dimension's
+   *  native scale. When omitted it auto-scales off observed magnitudes:
+   *  0.05 on [0,1], 5 on 0-100. */
+  regressionTolerance?: number;
+  /** Total $ budget for the complete improvement run. Requires
+   *  `GateContext.costLedger`; missing or incomplete accounting holds. */
+  budgetUsd?: number;
+  /** Static artifact-screening cases. Only `expected: 'ignore'` cases without
+   *  tool assertions are valid because this check does not dispatch case inputs
+   *  or observe tool calls. */
+  redTeamBattery?: RedTeamCase[];
+  /** Shared run history, oldest first. Supplying history does not enable either
+   *  monitoring check; configure `rewardHacking` and/or `canary` explicitly. */
+  recentRuns?: RunRecord[];
+  /** Enable reward-hacking monitoring with a caller-owned independent truth channel. */
+  rewardHacking?: DefaultProductionRewardHackingOptions;
+  /** Enable canary monitoring. Pass `{}` to use the canary defaults. */
+  canary?: CanaryOptions;
+  /** Optional checks that must be evaluated even when their normal input is
+   *  absent. Configuring a check's input also makes that check required.
+   *  Missing evidence always records `not_evaluated`; required unevaluated
+   *  checks hold the release decision. Held-out significance is always required. */
+  requiredChecks?: DefaultProductionGateCheck[];
+}
+/**
+ * Opinionated production gate composing held-out significance, red-team, reward-hacking, and canary checks into a single `Gate.decide` decision.
+ */
+declare function defaultProductionGate<TArtifact, TScenario extends Scenario>(options: DefaultProductionGateOptions): Gate<TArtifact, TScenario>;
+//#endregion
+//#region src/campaign/gates/heldout-gate.d.ts
+interface HeldOutGateOptions<TScenario extends Scenario = Scenario> {
+  scenarios: TScenario[];
+  /** Effect-size threshold the CI lower bound must clear, in the judge's native
+   *  scale. Default 0.5. Equality holds; CI.low must be greater than this value. */
+  deltaThreshold?: number;
+  /** Bootstrap CI confidence. Default 0.95. */
+  confidence?: number;
+  /** Minimum paired holdout observations to claim significance. The exact
+   *  small-sample test may require more observations at the selected
+   *  confidence. Default 3. */
+  minProductiveRuns?: number;
+  /** Bootstrap resamples. Default 2000. */
+  resamples?: number;
+  /** Fixed bootstrap seed for deterministic verdicts. Default 1337. */
+  bootstrapSeed?: number;
+}
+/**
+ * Composable held-out gate: ships only when the lower bound of the DECIDING
+ * paired interval on the candidate-minus-baseline composite delta clears
+ * `deltaThreshold` — Tango's score interval on a pass/fail holdout, the mean
+ * bootstrap otherwise. See {@link decidePairedPromotion}.
+ */
+declare function heldOutGate<TArtifact, TScenario extends Scenario>(options: HeldOutGateOptions<TScenario>): Gate<TArtifact, TScenario>;
+//#endregion
+//#region src/campaign/optimizer-model.d.ts
+type OptimizerModelBudget = ExternalOptimizerModelBudget;
+/** One metered model path supplied by the package that owns execution. */
+interface OpenAICompatibleOptimizerModel {
+  model: string;
+  budget: OptimizerModelBudget;
+  /** Caller-owned execution path, such as Runtime's exact AgentProfile adapter. */
+  call: ExternalOptimizerModelCall;
+  /** Stable public identity included in resumable-run compatibility. */
+  callRef: string;
+}
+//#endregion
+//#region src/campaign/gepa-optimization-method.d.ts
+/** Shared settings for one bounded GEPA engine invocation. */
+interface GepaEngineOptions {
+  /** GEPA engine name. GEPA validates names available in its Python runtime. */
+  engine: string;
+  /** Optional billed-USD stop. Omit when the execution owner reports USD as unknown. */
+  maxProposerCostUsd?: number;
+  /** Maximum concurrent evaluations inside this engine. Default: 1. */
+  maxConcurrency?: number;
+  /** Stop the engine after it reaches this score. */
+  stopAtScore?: number;
+  /** Isolate agent-based engines. Default: true. */
+  sandbox?: boolean;
+  /**
+   * JSON-safe configuration for the registered GEPA engine.
+   * Python callables and class instances cannot cross the process boundary.
+   */
+  engineConfig?: Record<string, unknown>;
+}
+/** One independently budgeted GEPA engine invocation. */
+interface GepaEngineRun extends GepaEngineOptions {
+  /** Maximum callback evaluations this engine may consume. */
+  maxEvaluations: number;
+}
+/** An engine in an adaptive run. All engines share the recipe evaluation limit. */
+type GepaAdaptiveEngineRun = GepaEngineOptions;
+/**
+ * A direct mapping to a GEPA optimization recipe.
+ *
+ * GEPA owns every search and composition operation represented here. Tangle
+ * supplies the candidate, data, execution callback, judges, and budgets.
+ */
+type GepaOptimizationRecipe = {
+  kind: 'engine';
+  run: GepaEngineRun;
+} | {
+  kind: 'sequential';
+  runs: readonly GepaEngineRun[];
+} | {
+  kind: 'adaptive-sequential';
+  runs: readonly GepaAdaptiveEngineRun[];
+  /** One evaluation budget shared by every adaptive stage. */
+  maxEvaluations: number;
+  /** Switch engines after this many evaluations without improvement. */
+  plateauEvaluations: number;
+  patience?: number;
+  minEvaluationsPerStage?: number;
+  improvementEpsilon?: number;
+  cycle?: boolean;
+  maxSwitches?: number;
+  maxConcurrency?: number;
+} | {
+  kind: 'best-of';
+  runs: readonly GepaEngineRun[];
+  maxWorkers?: number;
+} | {
+  kind: 'vote';
+  runs: readonly GepaEngineRun[];
+  maxWorkers?: number;
+} | {
+  kind: 'omni';
+  explore: readonly GepaEngineRun[];
+  continueWith: GepaEngineRun;
+  maxWorkers?: number;
+};
+/** The command that runs the Python GEPA bridge. */
+type GepaRunnerCommand = ExternalOptimizerRunnerCommand;
+interface GepaOptimizationMethodConfig<TScenario extends Scenario, TArtifact = unknown> {
+  /** Unique comparison-method name. Default identifies the GEPA recipe. */
+  name?: string;
+  /** A direct GEPA recipe. */
+  recipe: GepaOptimizationRecipe;
+  /** Plain-language goal shown to the external optimizer. */
+  objective: string;
+  /** Stable identity for the dispatch, judges, model settings, and scoring logic. */
+  evaluationId: string;
+  /** Optional bounded context about the surface and task. */
+  background?: string;
+  /**
+   * Public dotted Python modules imported before GEPA resolves engine names.
+   * Each module should call GEPA's official `register_engine()` API at import.
+   */
+  engineModules?: readonly string[];
+  /** Reject external candidates longer than this. Default: 200,000 characters. */
+  maxCandidateChars?: number;
+  /** Reject serialized score evidence longer than this. Default: 100,000 characters. */
+  maxEvidenceChars?: number;
+  /** Candidate-evaluation callback byte limits. Omitted fields use finite defaults. */
+  evaluationCallbackLimits?: Partial<ExternalOptimizerCallbackLimits>;
+  /** End the bridge process after this many milliseconds. Default: 30 minutes. */
+  timeoutMs?: number;
+  /**
+   * OpenAI-compatible model used by standard GEPA reflection.
+   * Calls pass through Agent Eval's local model proxy. Every recipe engine must
+   * be `gepa` when this is set.
+   */
+  optimizer?: OpenAICompatibleOptimizerModel;
+  /**
+   * Decide what the external optimizer may read for a train or selection case.
+   * The returned value must be JSON-serializable. The final comparison cases
+   * are not accepted by this API and cannot be serialized here.
+   */
+  describeScenario?: (scenario: TScenario) => unknown;
+  /** Optional bounded artifact evidence returned to GEPA after each evaluation. */
+  describeArtifact?: (artifact: TArtifact, scenario: TScenario) => unknown;
+  /** Default: `never`. Compatible runs resume only when explicitly enabled. */
+  resume?: ExternalOptimizerResumeMode;
+  /**
+   * Required for resumable direct GEPA runs because upstream state uses Python
+   * pickle. Enable only for state created locally in a directory you control.
+   */
+  trustResumeState?: boolean;
+  runner?: GepaRunnerCommand;
+}
+/**
+ * Turn an optional GEPA installation into an `OptimizationMethod`.
+ *
+ * GEPA receives only serialized train and selection cases. The caller's final
+ * test partition stays inside `compareOptimizationMethods`, which invokes this
+ * method without a test-set field. The local callback routes every candidate
+ * evaluation through the same dispatch and judges used by other methods.
+ */
+declare function gepaOptimizationMethod<TScenario extends Scenario, TArtifact>(config: GepaOptimizationMethodConfig<TScenario, TArtifact>): OptimizationMethod<TScenario, TArtifact>;
+//#endregion
+//#region src/campaign/skillopt-optimization-method.d.ts
+interface SkillOptTrainerConfig {
+  epochs: number;
+  batchSize: number;
+  accumulation?: number;
+  editBudget?: number;
+  minEditBudget?: number;
+  analystWorkers?: number;
+  minibatchSize?: number;
+  mergeBatchSize?: number;
+  maxAnalystRounds?: number;
+  evaluationWorkers?: number;
+  learningRateSchedule?: 'constant' | 'linear' | 'cosine' | 'autonomous';
+  learningRateControl?: 'fixed' | 'autonomous' | 'none';
+  updateMode?: 'patch' | 'rewrite_from_suggestions' | 'full_rewrite_minibatch';
+  failureOnly?: boolean;
+  useSlowUpdate?: boolean;
+  useMetaSkill?: boolean;
+  /**
+   * Additional flat SkillOpt trainer settings. Tangle overwrites data,
+   * output, split, seed, validation, and activation settings.
+   */
+  overrides?: Record<string, unknown>;
+}
+type SkillOptRunnerCommand = ExternalOptimizerRunnerCommand;
+interface SkillOptOptimizationMethodConfig<TScenario extends Scenario, TArtifact = unknown> {
+  name?: string;
+  /** Goal included with every described train and selection case. */
+  objective: string;
+  background?: string;
+  /** Stable identity for the dispatch, judges, model settings, and scoring logic. */
+  evaluationId: string;
+  trainer: SkillOptTrainerConfig;
+  /**
+   * OpenAI-compatible model connection and hard limits for SkillOpt's own
+   * optimizer calls.
+   */
+  optimizer: OpenAICompatibleOptimizerModel;
+  /** Hard cap on candidate-case callback requests. */
+  maxEvaluations: number;
+  /** Scores at or above this value count as hard successes. Default: 1. */
+  hardScoreThreshold?: number;
+  maxCandidateChars?: number;
+  /** Maximum serialized scenario plus evaluation evidence. Default: 100,000. */
+  maxEvidenceChars?: number;
+  /** Candidate-evaluation callback byte limits. Omitted fields use finite defaults. */
+  evaluationCallbackLimits?: Partial<ExternalOptimizerCallbackLimits>;
+  timeoutMs?: number;
+  describeScenario?: (scenario: TScenario) => unknown;
+  describeArtifact?: (artifact: TArtifact, scenario: TScenario) => unknown;
+  resume?: ExternalOptimizerResumeMode;
+  runner?: SkillOptRunnerCommand;
+}
+/** Run Microsoft's SkillOpt trainer as a complete optimization method. */
+declare function skillOptOptimizationMethod<TScenario extends Scenario, TArtifact>(config: SkillOptOptimizationMethodConfig<TScenario, TArtifact>): OptimizationMethod<TScenario, TArtifact>;
+//#endregion
+export { campaignScenarioIdentity as A, runReferenceEquivalenceJudge as B, ExternalTextOptimizerContext as C, decodeExternalTextCandidate as D, ExternalTextEvaluationResponse as E, ReferenceEquivalenceJudgeInput as F, ReferenceEquivalenceJudgeOptions as I, ReferenceEquivalenceJudgeResult as L, campaignSplitDigestFromIdentities as M, REFERENCE_EQUIVALENCE_INPUT_LIMITS as N, assertCampaignDesign as O, REFERENCE_EQUIVALENCE_JUDGE_VERSION as P, ReferenceEquivalenceScenario as R, ExternalTextOptimizationMethodConfig as S, ExternalOptimizationExample as T, DefaultProductionGateOptions as _, GepaAdaptiveEngineRun as a, composeGate as b, GepaOptimizationMethodConfig as c, gepaOptimizationMethod as d, OpenAICompatibleOptimizerModel as f, DefaultProductionGateCheck as g, heldOutGate as h, skillOptOptimizationMethod as i, campaignSplitDigest as j, assertCampaignSplitIdentity as k, GepaOptimizationRecipe as l, HeldOutGateOptions as m, SkillOptRunnerCommand as n, GepaEngineOptions as o, OptimizerModelBudget as p, SkillOptTrainerConfig as r, GepaEngineRun as s, SkillOptOptimizationMethodConfig as t, GepaRunnerCommand as u, DefaultProductionRewardHackingOptions as v, ExternalTextOptimizerResult as w, externalTextOptimizationMethod as x, defaultProductionGate as y, createReferenceEquivalenceJudge as z };
+//# sourceMappingURL=skillopt-optimization-method-C5cotF4E.d.ts.map

package/dist/skillopt-optimization-method-C5cotF4E.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"skillopt-optimization-method-C5cotF4E.d.ts","names":[],"sources":["../src/reference-equivalence-judge.ts","../src/campaign/coverage.ts","../src/campaign/external-text-evaluation.ts","../src/campaign/external-text-optimization-contract.ts","../src/campaign/external-text-optimization.ts","../src/campaign/gates/compose.ts","../src/campaign/gates/default-production-gate.ts","../src/campaign/gates/heldout-gate.ts","../src/campaign/optimizer-model.ts","../src/campaign/gepa-optimization-method.ts","../src/campaign/skillopt-optimization-method.ts"],"mappings":"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"}