@tangle-network/agent-eval 0.108.1 → 0.110.0

package/dist/product-benchmark/index.js

@@ -1,37 +0,0 @@
-import {
-  assertProductBenchmarkRun,
-  buildProductBenchmarkManifest,
-  exportProductBenchmark,
-  exportProductBenchmarkRuns,
-  findProductBenchmarkArtifacts,
-  productBenchmarkIntegrityFailures,
-  productBenchmarkMutableSurfaces,
-  productBenchmarkRepoIdentity,
-  productBenchmarkSplits,
-  readProductBenchmarkManifest,
-  readProductBenchmarkRecords,
-  runRecordToProductBenchmarkRecord,
-  validateProductBenchmarkManifest,
-  validateProductBenchmarkRecord,
-  validateProductBenchmarkRun
-} from "../chunk-FOUG2VVS.js";
-import "../chunk-ONWEPEDO.js";
-import "../chunk-PZ5AY32C.js";
-export {
-  assertProductBenchmarkRun,
-  buildProductBenchmarkManifest,
-  exportProductBenchmark,
-  exportProductBenchmarkRuns,
-  findProductBenchmarkArtifacts,
-  productBenchmarkIntegrityFailures,
-  productBenchmarkMutableSurfaces,
-  productBenchmarkRepoIdentity,
-  productBenchmarkSplits,
-  readProductBenchmarkManifest,
-  readProductBenchmarkRecords,
-  runRecordToProductBenchmarkRecord,
-  validateProductBenchmarkManifest,
-  validateProductBenchmarkRecord,
-  validateProductBenchmarkRun
-};
-//# sourceMappingURL=index.js.map

package/dist/product-benchmark/index.js.map

@@ -1 +0,0 @@
-{"version":3,"sources":[],"sourcesContent":[],"mappings":"","names":[]}

package/dist/red-team-KmmiqBlY.d.ts

@@ -1,63 +0,0 @@
-import { a as DatasetScenario, b as Dataset } from './dataset-DS7ytHZU.js';
-import { T as TraceStore } from './store-BcFXE6LG.js';
-
-/**
- * Red-team battery — adversarial scenario corpus with per-category
- * scorers.
- *
- * Every scenario is a `DatasetScenario` with a `redTeam: {...}` payload
- * that declares: category, expected refusal, attack surface. Scorers
- * inspect the agent's output + trajectory and return a PASS/FAIL per
- * category. Aggregated via `redTeamReport`.
- *
- * The built-in corpus is intentionally conservative — 40 cases
- * covering the most-seen attack patterns. Extend via `extendCorpus`.
- */
-
-type RedTeamCategory = 'prompt_injection_direct' | 'prompt_injection_indirect' | 'jailbreak_persona' | 'jailbreak_dan' | 'pii_leak' | 'permission_escalation' | 'data_exfil' | 'policy_override';
-interface RedTeamPayload {
-    category: RedTeamCategory;
-    /** The hostile input the agent sees. */
-    input: string;
-    /**
-     * What a safe agent should do: "refuse" means explicit refusal,
-     * "ignore" means process benignly without executing the attack.
-     */
-    expected: 'refuse' | 'ignore';
-    /** Substring(s) that MUST NOT appear in output. */
-    forbiddenStrings?: string[];
-    /** Tool names the agent MUST NOT call for this scenario. */
-    forbiddenTools?: string[];
-}
-interface RedTeamCase extends DatasetScenario {
-    payload: RedTeamPayload;
-}
-interface RedTeamFinding {
-    scenarioId: string;
-    category: RedTeamCategory;
-    passed: boolean;
-    reason: string;
-    evidence?: string;
-}
-interface RedTeamReport {
-    findings: RedTeamFinding[];
-    passRateByCategory: Record<RedTeamCategory, number>;
-    overallPassRate: number;
-}
-/** Ship a canonical, small corpus. Consumers extend via `extendCorpus`. */
-declare const DEFAULT_RED_TEAM_CORPUS: RedTeamCase[];
-declare function redTeamDataset(extraCases?: RedTeamCase[]): Dataset;
-/**
- * Score a single agent response against the red-team case.
- * `toolCalls` should be the names of tools the agent invoked during the run.
- */
-declare function scoreRedTeamOutput(output: string, toolCalls: string[], rtCase: RedTeamCase): RedTeamFinding;
-/** Aggregate red-team findings into per-category pass rates. */
-declare function redTeamReport(findings: RedTeamFinding[]): RedTeamReport;
-/**
- * Extract the tool-call names from a corpus run — convenience for the
- * common pipeline (run the scenario → score the run).
- */
-declare function toolNamesForRun(store: TraceStore, runId: string): Promise<string[]>;
-
-export { DEFAULT_RED_TEAM_CORPUS as D, type RedTeamCase as R, type RedTeamCategory as a, type RedTeamFinding as b, type RedTeamPayload as c, type RedTeamReport as d, redTeamReport as e, redTeamDataset as r, scoreRedTeamOutput as s, toolNamesForRun as t };

package/dist/redact-B40YG2M_.d.ts

@@ -1,45 +0,0 @@
-/**
- * Redaction — remove PII / secrets from trace payloads before persist.
- *
- * Pre-persistence rules mean raw traces in storage are already scrubbed.
- * Unredacted variants (for debugging / post-mortems) live in a separate
- * storage layer with stricter access controls; this module only covers
- * the default scrub-then-persist path.
- *
- * Rules compose: pass an array of `RedactionRule`, each is applied in
- * order. Strings that match get replaced with a tagged sentinel so the
- * eval framework can count how many redactions happened per run
- * (surfaced via `redaction_applied` events).
- */
-interface RedactionRule {
-    id: string;
-    pattern: RegExp;
-    /** Replacement — e.g. '[PII:email]'. Defaults to `[redacted:{id}]`. */
-    replacement?: string;
-}
-interface RedactionReport {
-    redactionCount: number;
-    byRule: Record<string, number>;
-}
-/** OWASP / common-sense defaults — extend per-domain. */
-declare const DEFAULT_REDACTION_RULES: RedactionRule[];
-declare const REDACTION_VERSION = "1.0.0";
-/**
- * Redact a single string. Returns the new string and a per-rule count of
- * how many substitutions fired.
- */
-declare function redactString(input: string, rules?: RedactionRule[]): {
-    output: string;
-    report: RedactionReport;
-};
-/**
- * Walk a JSON-ish value applying `redactString` to every string leaf.
- * Arrays and plain objects are recursed; other types pass through
- * untouched. Circular references throw — traces should be tree-shaped.
- */
-declare function redactValue(value: unknown, rules?: RedactionRule[], report?: RedactionReport): {
-    value: unknown;
-    report: RedactionReport;
-};
-
-export { DEFAULT_REDACTION_RULES as D, type RedactionRule as R, type RedactionReport as a, REDACTION_VERSION as b, redactValue as c, redactString as r };

package/dist/rubric-Cc6UHvUb.d.ts

@@ -1,73 +0,0 @@
-import { S as Span, J as JudgeSpan } from './schema-m0gsnbt3.js';
-import { T as TraceStore } from './store-BcFXE6LG.js';
-import { T as Trajectory, a as TrajectoryStep } from './trajectory-2TkpSEVh.js';
-
-/**
- * Process Reward Modeling — per-step rubric grading.
- *
- * A StepRubric inspects one span and returns a score + rationale.
- * PrmGrader applies an array of rubrics to every LLM span in a
- * trajectory (consumers can broaden to tool/retrieval spans via the
- * `kind` filter on each rubric).
- *
- * Why this matters: outcome-only eval (did the final artifact work?)
- * gives sparse reward — most agent turns are unattributable. PRMs
- * densify the signal so optimizers and RL fine-tuning can assign
- * credit per turn.
- */
-
-interface StepContext {
-    trajectory: Trajectory;
-    step: TrajectoryStep;
-    /** Steps preceding `step` in trajectory order. */
-    prior: TrajectoryStep[];
-    /** Steps following `step`. */
-    next: TrajectoryStep[];
-}
-interface StepRubric {
-    id: string;
-    /** Only grade spans of these kinds (default: all). */
-    kinds?: Array<Span['kind']>;
-    /** Weight in the aggregate score. Default 1. */
-    weight?: number;
-    /** Returns score in 0..1 + optional rationale/evidence. Return `null` to
-     *  skip grading (rubric doesn't apply to this step). */
-    grade: (ctx: StepContext) => Promise<{
-        score: number;
-        rationale?: string;
-        evidence?: string;
-    } | null>;
-}
-interface GradedStep {
-    spanId: string;
-    rubricId: string;
-    score: number;
-    weight: number;
-    rationale?: string;
-    evidence?: string;
-}
-interface PrmGradedTrace {
-    runId: string;
-    steps: GradedStep[];
-    /** Weighted mean of all graded steps; 0..1. */
-    aggregateScore: number;
-    /** Number of spans graded — useful for sanity-checking coverage. */
-    gradedCount: number;
-    /** Number of spans in the trajectory that no rubric matched. */
-    ungradedCount: number;
-}
-declare class PrmGrader {
-    private rubrics;
-    constructor(rubrics: StepRubric[]);
-    /**
-     * Grade every eligible span in a run. Emits a JudgeVerdict span for each
-     * (rubric × span) verdict so the result is visible to downstream pipelines
-     * (judgeAgreementView, etc.) — PRM is just "a judge that runs per span."
-     */
-    grade(store: TraceStore, runId: string): Promise<PrmGradedTrace>;
-}
-/** Helper: reads JudgeVerdict spans that PRM emitted so downstream pipelines
- *  can distinguish PRM verdicts from human or top-level LLM judges. */
-declare function isPrmVerdict(verdict: JudgeSpan): boolean;
-
-export { type GradedStep as G, type PrmGradedTrace as P, type StepRubric as S, PrmGrader as a, type StepContext as b, isPrmVerdict as i };

package/dist/run-critic-CmMf05uV.d.ts

@@ -1,56 +0,0 @@
-import { R as Run, S as Span, a as TraceEvent, A as Artifact, B as BudgetLedgerEntry } from './schema-m0gsnbt3.js';
-import { T as TraceStore } from './store-BcFXE6LG.js';
-
-interface RunScore {
-    success: number;
-    goalProgress: number;
-    repoGroundedness: number;
-    driftPenalty: number;
-    toolUseQuality: number;
-    patchQuality: number;
-    testReality: number;
-    finalGate: number;
-    reviewerBlockers: number;
-    costUsd: number;
-    wallSeconds: number;
-    notes?: string[];
-}
-interface RunScoreWeights {
-    success: number;
-    goalProgress: number;
-    repoGroundedness: number;
-    driftPenalty: number;
-    toolUseQuality: number;
-    patchQuality: number;
-    testReality: number;
-    finalGate: number;
-    reviewerBlockers: number;
-    costUsd: number;
-    wallSeconds: number;
-}
-declare const DEFAULT_RUN_SCORE_WEIGHTS: RunScoreWeights;
-declare function aggregateRunScore(score: RunScore, weights?: Partial<RunScoreWeights>): number;
-declare function clamp01(value: number): number;
-
-interface RunTrace {
-    run: Run;
-    spans: Span[];
-    events: TraceEvent[];
-    artifacts: Artifact[];
-    budget: BudgetLedgerEntry[];
-}
-interface RunCriticOptions {
-    weights?: Partial<RunScoreWeights>;
-    driftPatterns?: RegExp[];
-}
-declare class RunCritic {
-    private readonly weights?;
-    private readonly driftPatterns;
-    constructor(options?: RunCriticOptions);
-    score(store: TraceStore, runId: string): Promise<RunScore>;
-    scoreTrace(trace: RunTrace): RunScore;
-    rank(score: RunScore): number;
-    private isDrift;
-}
-
-export { DEFAULT_RUN_SCORE_WEIGHTS as D, type RunScore as R, type RunTrace as a, type RunScoreWeights as b, RunCritic as c, type RunCriticOptions as d, aggregateRunScore as e, clamp01 as f };

package/dist/sink-fetch-B1Yg4Til.d.ts

@@ -1,101 +0,0 @@
-/**
- * Fleet telemetry envelope — agent-eval's portable observability shape.
- *
- * Designed so any consumer (Node CLI, Cloudflare Worker, Lambda, browser
- * extension) can emit structured rows describing one unit of work — a page
- * audit, a tool call, an evolve round, a full agent run — to a central sink.
- *
- * The schema is intentionally a strict superset of agent-eval's `Run` shape
- * so a future TraceStore adapter can promote envelopes into traces without
- * translation.
- */
-declare const TELEMETRY_SCHEMA_VERSION = 1;
-/** Discriminator for the unit of work this envelope describes. */
-type TelemetryKind = 'agent-run' | 'design-audit-page' | 'design-audit-run' | 'design-evolve-round' | 'design-evolve-run' | 'gepa-trial' | 'gepa-generation' | 'tool-call' | 'judge-verdict' | 'custom';
-interface TelemetryEnvelope {
-    schemaVersion: typeof TELEMETRY_SCHEMA_VERSION;
-    envelopeId: string;
-    runId: string;
-    timestamp: string;
-    parentRunId?: string;
-    source: TelemetrySource;
-    model?: TelemetryModel;
-    kind: TelemetryKind;
-    ok: boolean;
-    durationMs: number;
-    data: Record<string, unknown>;
-    metrics: Record<string, number>;
-    tags?: Record<string, string>;
-    error?: string;
-}
-interface TelemetrySource {
-    /** Repo identity — basename of cwd plus git remote if discoverable. */
-    repo: string;
-    cwd: string;
-    gitSha?: string;
-    gitBranch?: string;
-    cliVersion: string;
-    /** What was invoked, e.g. `design-audit`, `bad run`, `gepa --target`. */
-    invocation: string;
-    /** Sanitised argv minus secrets. */
-    argv?: string[];
-    /**
-     * Multi-tenant identity. Set when the consumer runs inside a hosted
-     * product so a fleet rollup can group by tenant without leaking customer
-     * URLs or PII.
-     */
-    tenantId?: string;
-    /** Optional sub-tenant identity (project, suite, walkthrough, customer). */
-    customerId?: string;
-    /** SHA-256 (12 hex) of the API key used to authenticate this run, when applicable. */
-    apiKeyHash?: string;
-}
-interface TelemetryModel {
-    provider: string;
-    name: string;
-    /** SHA-256 (12 hex chars) of the prompt(s) used. */
-    promptHash?: string;
-    /** SHA-256 (12 hex chars) of the composed rubric body, if applicable. */
-    rubricHash?: string;
-}
-
-/**
- * Workers-safe telemetry sinks — only `fetch` and pure JS. No `fs`, no
- * `child_process`. Safe to import from a Cloudflare Worker, Lambda, edge
- * function, or browser extension.
- *
- * For Node-only file persistence, import from '@tangle-network/agent-eval/telemetry/file'.
- */
-
-interface TelemetrySink {
-    emit(envelope: TelemetryEnvelope): Promise<void> | void;
-    close?(): Promise<void> | void;
-}
-/** Best-effort POST to a remote collector. Fire-and-forget; never throws. */
-declare class HttpTelemetrySink implements TelemetrySink {
-    private readonly endpoint;
-    private readonly bearer?;
-    private inflight;
-    constructor(endpoint: string, bearer?: string | undefined);
-    emit(envelope: TelemetryEnvelope): void;
-    close(): Promise<void>;
-}
-/** Fanout to multiple sinks — failures in one do not affect others. */
-declare class FanoutTelemetrySink implements TelemetrySink {
-    private readonly sinks;
-    constructor(sinks: TelemetrySink[]);
-    emit(envelope: TelemetryEnvelope): void;
-    close(): Promise<void>;
-}
-/** No-op sink — used when telemetry is explicitly disabled. */
-declare class NullTelemetrySink implements TelemetrySink {
-    emit(): void;
-}
-/** In-memory sink — useful for tests + downstream adapters. */
-declare class InMemoryTelemetrySink implements TelemetrySink {
-    readonly envelopes: TelemetryEnvelope[];
-    emit(envelope: TelemetryEnvelope): void;
-    clear(): void;
-}
-
-export { FanoutTelemetrySink as F, HttpTelemetrySink as H, InMemoryTelemetrySink as I, NullTelemetrySink as N, type TelemetryKind as T, type TelemetryModel as a, type TelemetrySource as b, type TelemetrySink as c, TELEMETRY_SCHEMA_VERSION as d, type TelemetryEnvelope as e };

package/dist/telemetry/file.d.ts

@@ -1,19 +0,0 @@
-import { c as TelemetrySink, e as TelemetryEnvelope } from '../sink-fetch-B1Yg4Til.js';
-
-/**
- * Node-only file sink. Imports `node:fs` — DO NOT import this from a Worker
- * or edge runtime; use `./sink-fetch` instead.
- */
-
-/** Append envelopes to a JSONL file, partitioned by repo + date. */
-declare class FileTelemetrySink implements TelemetrySink {
-    private readonly baseDir;
-    private streams;
-    constructor(baseDir: string);
-    emit(envelope: TelemetryEnvelope): void;
-    close(): Promise<void>;
-}
-/** Default location for local telemetry, mirroring bad CLI's convention. */
-declare function defaultTelemetryDir(homeDir: string, override?: string): string;
-
-export { FileTelemetrySink, defaultTelemetryDir };

package/dist/telemetry/file.js

@@ -1,45 +0,0 @@
-import "../chunk-PZ5AY32C.js";
-
-// src/telemetry/sink-file.ts
-import * as fs from "fs";
-import * as path from "path";
-var FileTelemetrySink = class {
-  constructor(baseDir) {
-    this.baseDir = baseDir;
-    fs.mkdirSync(baseDir, { recursive: true });
-  }
-  baseDir;
-  streams = /* @__PURE__ */ new Map();
-  emit(envelope) {
-    const date = envelope.timestamp.slice(0, 10);
-    const repo = envelope.source.repo || "unknown";
-    const key = `${repo}/${date}`;
-    let stream = this.streams.get(key);
-    if (!stream) {
-      const dir = path.join(this.baseDir, repo);
-      fs.mkdirSync(dir, { recursive: true });
-      stream = fs.createWriteStream(path.join(dir, `${date}.jsonl`), {
-        flags: "a",
-        encoding: "utf-8"
-      });
-      this.streams.set(key, stream);
-    }
-    stream.write(`${JSON.stringify(envelope)}
-`);
-  }
-  async close() {
-    const closes = Array.from(this.streams.values()).map(
-      (s) => new Promise((resolve) => s.end(() => resolve()))
-    );
-    this.streams.clear();
-    await Promise.all(closes);
-  }
-};
-function defaultTelemetryDir(homeDir, override) {
-  return override || path.join(homeDir, ".agent-eval", "telemetry");
-}
-export {
-  FileTelemetrySink,
-  defaultTelemetryDir
-};
-//# sourceMappingURL=file.js.map

package/dist/telemetry/file.js.map

@@ -1 +0,0 @@
-{"version":3,"sources":["../../src/telemetry/sink-file.ts"],"sourcesContent":["/**\n * Node-only file sink. Imports `node:fs` — DO NOT import this from a Worker\n * or edge runtime; use `./sink-fetch` instead.\n */\n\nimport * as fs from 'node:fs'\nimport * as path from 'node:path'\nimport type { TelemetryEnvelope } from './schema'\nimport type { TelemetrySink } from './sink-fetch'\n\n/** Append envelopes to a JSONL file, partitioned by repo + date. */\nexport class FileTelemetrySink implements TelemetrySink {\n  private streams = new Map<string, fs.WriteStream>()\n\n  constructor(private readonly baseDir: string) {\n    fs.mkdirSync(baseDir, { recursive: true })\n  }\n\n  emit(envelope: TelemetryEnvelope): void {\n    const date = envelope.timestamp.slice(0, 10) // YYYY-MM-DD\n    const repo = envelope.source.repo || 'unknown'\n    const key = `${repo}/${date}`\n    let stream = this.streams.get(key)\n    if (!stream) {\n      const dir = path.join(this.baseDir, repo)\n      fs.mkdirSync(dir, { recursive: true })\n      stream = fs.createWriteStream(path.join(dir, `${date}.jsonl`), {\n        flags: 'a',\n        encoding: 'utf-8',\n      })\n      this.streams.set(key, stream)\n    }\n    stream.write(`${JSON.stringify(envelope)}\\n`)\n  }\n\n  async close(): Promise<void> {\n    const closes = Array.from(this.streams.values()).map(\n      (s) => new Promise<void>((resolve) => s.end(() => resolve())),\n    )\n    this.streams.clear()\n    await Promise.all(closes)\n  }\n}\n\n/** Default location for local telemetry, mirroring bad CLI's convention. */\nexport function defaultTelemetryDir(homeDir: string, override?: string): string {\n  return override || path.join(homeDir, '.agent-eval', 'telemetry')\n}\n"],"mappings":";;;AAKA,YAAY,QAAQ;AACpB,YAAY,UAAU;AAKf,IAAM,oBAAN,MAAiD;AAAA,EAGtD,YAA6B,SAAiB;AAAjB;AAC3B,IAAG,aAAU,SAAS,EAAE,WAAW,KAAK,CAAC;AAAA,EAC3C;AAAA,EAF6B;AAAA,EAFrB,UAAU,oBAAI,IAA4B;AAAA,EAMlD,KAAK,UAAmC;AACtC,UAAM,OAAO,SAAS,UAAU,MAAM,GAAG,EAAE;AAC3C,UAAM,OAAO,SAAS,OAAO,QAAQ;AACrC,UAAM,MAAM,GAAG,IAAI,IAAI,IAAI;AAC3B,QAAI,SAAS,KAAK,QAAQ,IAAI,GAAG;AACjC,QAAI,CAAC,QAAQ;AACX,YAAM,MAAW,UAAK,KAAK,SAAS,IAAI;AACxC,MAAG,aAAU,KAAK,EAAE,WAAW,KAAK,CAAC;AACrC,eAAY,qBAAuB,UAAK,KAAK,GAAG,IAAI,QAAQ,GAAG;AAAA,QAC7D,OAAO;AAAA,QACP,UAAU;AAAA,MACZ,CAAC;AACD,WAAK,QAAQ,IAAI,KAAK,MAAM;AAAA,IAC9B;AACA,WAAO,MAAM,GAAG,KAAK,UAAU,QAAQ,CAAC;AAAA,CAAI;AAAA,EAC9C;AAAA,EAEA,MAAM,QAAuB;AAC3B,UAAM,SAAS,MAAM,KAAK,KAAK,QAAQ,OAAO,CAAC,EAAE;AAAA,MAC/C,CAAC,MAAM,IAAI,QAAc,CAAC,YAAY,EAAE,IAAI,MAAM,QAAQ,CAAC,CAAC;AAAA,IAC9D;AACA,SAAK,QAAQ,MAAM;AACnB,UAAM,QAAQ,IAAI,MAAM;AAAA,EAC1B;AACF;AAGO,SAAS,oBAAoB,SAAiB,UAA2B;AAC9E,SAAO,YAAiB,UAAK,SAAS,eAAe,WAAW;AAClE;","names":[]}

package/dist/telemetry/index.d.ts

@@ -1,38 +0,0 @@
-import { T as TelemetryKind, a as TelemetryModel, b as TelemetrySource, c as TelemetrySink } from '../sink-fetch-B1Yg4Til.js';
-export { F as FanoutTelemetrySink, H as HttpTelemetrySink, I as InMemoryTelemetrySink, N as NullTelemetrySink, d as TELEMETRY_SCHEMA_VERSION, e as TelemetryEnvelope } from '../sink-fetch-B1Yg4Til.js';
-
-/**
- * Telemetry client — thin wrapper that builds envelopes from `EmitArgs` and
- * delegates to a `TelemetrySink`. Pure logic; no I/O. Use this from any
- * runtime — Workers, Node, browser — and choose the sink accordingly.
- *
- * For an opinionated singleton with env-var-driven sink wiring (the bad CLI
- * pattern), see `./node-client.ts`.
- */
-
-interface EmitArgs {
-    kind: TelemetryKind;
-    runId: string;
-    parentRunId?: string;
-    ok: boolean;
-    durationMs: number;
-    data?: Record<string, unknown>;
-    metrics?: Record<string, number>;
-    tags?: Record<string, string>;
-    model?: TelemetryModel;
-    error?: string;
-    /** Override the source for this envelope. Falls back to `defaultSource`. */
-    source?: TelemetrySource;
-}
-declare class TelemetryClient {
-    private readonly sink;
-    private readonly defaultSource;
-    constructor(sink: TelemetrySink, defaultSource: TelemetrySource);
-    emit(args: EmitArgs): void;
-    close(): Promise<void>;
-}
-declare const SECRET_FLAGS: Set<string>;
-/** Strip likely-secret values from argv, preserving structure. */
-declare function sanitiseArgv(argv: string[]): string[];
-
-export { type EmitArgs, SECRET_FLAGS, TelemetryClient, TelemetryKind, TelemetryModel, TelemetrySink, TelemetrySource, sanitiseArgv };

package/dist/telemetry/index.js

@@ -1,130 +0,0 @@
-import "../chunk-PZ5AY32C.js";
-
-// src/telemetry/schema.ts
-var TELEMETRY_SCHEMA_VERSION = 1;
-
-// src/telemetry/client.ts
-var TelemetryClient = class {
-  constructor(sink, defaultSource) {
-    this.sink = sink;
-    this.defaultSource = defaultSource;
-  }
-  sink;
-  defaultSource;
-  emit(args) {
-    const envelope = {
-      schemaVersion: TELEMETRY_SCHEMA_VERSION,
-      envelopeId: makeEnvelopeId(),
-      runId: args.runId,
-      timestamp: (/* @__PURE__ */ new Date()).toISOString(),
-      source: args.source ?? this.defaultSource,
-      kind: args.kind,
-      ok: args.ok,
-      durationMs: args.durationMs,
-      data: args.data ?? {},
-      metrics: args.metrics ?? {},
-      ...args.parentRunId ? { parentRunId: args.parentRunId } : {},
-      ...args.model ? { model: args.model } : {},
-      ...args.tags ? { tags: args.tags } : {},
-      ...args.error ? { error: args.error } : {}
-    };
-    try {
-      this.sink.emit(envelope);
-    } catch {
-    }
-  }
-  async close() {
-    await this.sink.close?.();
-  }
-};
-function makeEnvelopeId() {
-  if (typeof crypto !== "undefined" && typeof crypto.randomUUID === "function") {
-    return crypto.randomUUID();
-  }
-  return `env-${Date.now().toString(36)}-${Math.random().toString(36).slice(2, 10)}`;
-}
-var SECRET_FLAGS = /* @__PURE__ */ new Set(["--api-key", "--bearer", "--token", "--password"]);
-function sanitiseArgv(argv) {
-  const out = [];
-  for (let i = 0; i < argv.length; i++) {
-    const a = argv[i];
-    if (SECRET_FLAGS.has(a)) {
-      out.push(a, "<redacted>");
-      i++;
-      continue;
-    }
-    if (/^(?:--api-key|--bearer|--token|--password)=/.test(a)) {
-      out.push(a.replace(/=.*$/, "=<redacted>"));
-      continue;
-    }
-    out.push(a);
-  }
-  return out;
-}
-
-// src/telemetry/sink-fetch.ts
-var HttpTelemetrySink = class {
-  constructor(endpoint, bearer) {
-    this.endpoint = endpoint;
-    this.bearer = bearer;
-  }
-  endpoint;
-  bearer;
-  inflight = /* @__PURE__ */ new Set();
-  emit(envelope) {
-    const body = JSON.stringify(envelope);
-    const headers = { "content-type": "application/json" };
-    if (this.bearer) headers.authorization = `Bearer ${this.bearer}`;
-    const promise = fetch(this.endpoint, { method: "POST", headers, body }).then(() => void 0).catch(() => void 0);
-    this.inflight.add(promise);
-    promise.finally(() => this.inflight.delete(promise));
-  }
-  async close() {
-    await Promise.allSettled(Array.from(this.inflight));
-  }
-};
-var FanoutTelemetrySink = class {
-  constructor(sinks) {
-    this.sinks = sinks;
-  }
-  sinks;
-  emit(envelope) {
-    for (const sink of this.sinks) {
-      try {
-        const result = sink.emit(envelope);
-        if (result && typeof result.catch === "function") {
-          ;
-          result.catch(() => void 0);
-        }
-      } catch {
-      }
-    }
-  }
-  async close() {
-    await Promise.allSettled(this.sinks.map((s) => Promise.resolve(s.close?.())));
-  }
-};
-var NullTelemetrySink = class {
-  emit() {
-  }
-};
-var InMemoryTelemetrySink = class {
-  envelopes = [];
-  emit(envelope) {
-    this.envelopes.push(envelope);
-  }
-  clear() {
-    this.envelopes.length = 0;
-  }
-};
-export {
-  FanoutTelemetrySink,
-  HttpTelemetrySink,
-  InMemoryTelemetrySink,
-  NullTelemetrySink,
-  SECRET_FLAGS,
-  TELEMETRY_SCHEMA_VERSION,
-  TelemetryClient,
-  sanitiseArgv
-};
-//# sourceMappingURL=index.js.map

package/dist/telemetry/index.js.map

@@ -1 +0,0 @@
-{"version":3,"sources":["../../src/telemetry/schema.ts","../../src/telemetry/client.ts","../../src/telemetry/sink-fetch.ts"],"sourcesContent":["/**\n * Fleet telemetry envelope — agent-eval's portable observability shape.\n *\n * Designed so any consumer (Node CLI, Cloudflare Worker, Lambda, browser\n * extension) can emit structured rows describing one unit of work — a page\n * audit, a tool call, an evolve round, a full agent run — to a central sink.\n *\n * The schema is intentionally a strict superset of agent-eval's `Run` shape\n * so a future TraceStore adapter can promote envelopes into traces without\n * translation.\n */\n\nexport const TELEMETRY_SCHEMA_VERSION = 1\n\n/** Discriminator for the unit of work this envelope describes. */\nexport type TelemetryKind =\n  | 'agent-run'\n  | 'design-audit-page'\n  | 'design-audit-run'\n  | 'design-evolve-round'\n  | 'design-evolve-run'\n  | 'gepa-trial'\n  | 'gepa-generation'\n  | 'tool-call'\n  | 'judge-verdict'\n  | 'custom'\n\nexport interface TelemetryEnvelope {\n  schemaVersion: typeof TELEMETRY_SCHEMA_VERSION\n  envelopeId: string\n  runId: string\n  timestamp: string\n  parentRunId?: string\n\n  source: TelemetrySource\n  model?: TelemetryModel\n  kind: TelemetryKind\n  ok: boolean\n  durationMs: number\n\n  data: Record<string, unknown>\n  metrics: Record<string, number>\n  tags?: Record<string, string>\n\n  error?: string\n}\n\nexport interface TelemetrySource {\n  /** Repo identity — basename of cwd plus git remote if discoverable. */\n  repo: string\n  cwd: string\n  gitSha?: string\n  gitBranch?: string\n  cliVersion: string\n  /** What was invoked, e.g. `design-audit`, `bad run`, `gepa --target`. */\n  invocation: string\n  /** Sanitised argv minus secrets. */\n  argv?: string[]\n  /**\n   * Multi-tenant identity. Set when the consumer runs inside a hosted\n   * product so a fleet rollup can group by tenant without leaking customer\n   * URLs or PII.\n   */\n  tenantId?: string\n  /** Optional sub-tenant identity (project, suite, walkthrough, customer). */\n  customerId?: string\n  /** SHA-256 (12 hex) of the API key used to authenticate this run, when applicable. */\n  apiKeyHash?: string\n}\n\nexport interface TelemetryModel {\n  provider: string\n  name: string\n  /** SHA-256 (12 hex chars) of the prompt(s) used. */\n  promptHash?: string\n  /** SHA-256 (12 hex chars) of the composed rubric body, if applicable. */\n  rubricHash?: string\n}\n","/**\n * Telemetry client — thin wrapper that builds envelopes from `EmitArgs` and\n * delegates to a `TelemetrySink`. Pure logic; no I/O. Use this from any\n * runtime — Workers, Node, browser — and choose the sink accordingly.\n *\n * For an opinionated singleton with env-var-driven sink wiring (the bad CLI\n * pattern), see `./node-client.ts`.\n */\n\nimport type { TelemetryEnvelope, TelemetryKind, TelemetryModel, TelemetrySource } from './schema'\nimport { TELEMETRY_SCHEMA_VERSION } from './schema'\nimport type { TelemetrySink } from './sink-fetch'\n\nexport interface EmitArgs {\n  kind: TelemetryKind\n  runId: string\n  parentRunId?: string\n  ok: boolean\n  durationMs: number\n  data?: Record<string, unknown>\n  metrics?: Record<string, number>\n  tags?: Record<string, string>\n  model?: TelemetryModel\n  error?: string\n  /** Override the source for this envelope. Falls back to `defaultSource`. */\n  source?: TelemetrySource\n}\n\nexport class TelemetryClient {\n  constructor(\n    private readonly sink: TelemetrySink,\n    private readonly defaultSource: TelemetrySource,\n  ) {}\n\n  emit(args: EmitArgs): void {\n    const envelope: TelemetryEnvelope = {\n      schemaVersion: TELEMETRY_SCHEMA_VERSION,\n      envelopeId: makeEnvelopeId(),\n      runId: args.runId,\n      timestamp: new Date().toISOString(),\n      source: args.source ?? this.defaultSource,\n      kind: args.kind,\n      ok: args.ok,\n      durationMs: args.durationMs,\n      data: args.data ?? {},\n      metrics: args.metrics ?? {},\n      ...(args.parentRunId ? { parentRunId: args.parentRunId } : {}),\n      ...(args.model ? { model: args.model } : {}),\n      ...(args.tags ? { tags: args.tags } : {}),\n      ...(args.error ? { error: args.error } : {}),\n    }\n    try {\n      this.sink.emit(envelope)\n    } catch {\n      // swallow — telemetry never breaks the calling code path\n    }\n  }\n\n  async close(): Promise<void> {\n    await this.sink.close?.()\n  }\n}\n\n/** Generate a UUIDv4 with whatever crypto is available (Node, Workers, browsers). */\nfunction makeEnvelopeId(): string {\n  if (typeof crypto !== 'undefined' && typeof crypto.randomUUID === 'function') {\n    return crypto.randomUUID()\n  }\n  // Last-resort fallback. Lower entropy but never throws.\n  return `env-${Date.now().toString(36)}-${Math.random().toString(36).slice(2, 10)}`\n}\n\nexport const SECRET_FLAGS = new Set(['--api-key', '--bearer', '--token', '--password'])\n\n/** Strip likely-secret values from argv, preserving structure. */\nexport function sanitiseArgv(argv: string[]): string[] {\n  const out: string[] = []\n  for (let i = 0; i < argv.length; i++) {\n    const a = argv[i]!\n    if (SECRET_FLAGS.has(a)) {\n      out.push(a, '<redacted>')\n      i++\n      continue\n    }\n    if (/^(?:--api-key|--bearer|--token|--password)=/.test(a)) {\n      out.push(a.replace(/=.*$/, '=<redacted>'))\n      continue\n    }\n    out.push(a)\n  }\n  return out\n}\n","/**\n * Workers-safe telemetry sinks — only `fetch` and pure JS. No `fs`, no\n * `child_process`. Safe to import from a Cloudflare Worker, Lambda, edge\n * function, or browser extension.\n *\n * For Node-only file persistence, import from '@tangle-network/agent-eval/telemetry/file'.\n */\n\nimport type { TelemetryEnvelope } from './schema'\n\nexport interface TelemetrySink {\n  emit(envelope: TelemetryEnvelope): Promise<void> | void\n  close?(): Promise<void> | void\n}\n\n/** Best-effort POST to a remote collector. Fire-and-forget; never throws. */\nexport class HttpTelemetrySink implements TelemetrySink {\n  private inflight = new Set<Promise<void>>()\n\n  constructor(\n    private readonly endpoint: string,\n    private readonly bearer?: string,\n  ) {}\n\n  emit(envelope: TelemetryEnvelope): void {\n    const body = JSON.stringify(envelope)\n    const headers: Record<string, string> = { 'content-type': 'application/json' }\n    if (this.bearer) headers.authorization = `Bearer ${this.bearer}`\n    const promise = fetch(this.endpoint, { method: 'POST', headers, body })\n      .then(() => undefined)\n      .catch(() => undefined)\n    this.inflight.add(promise)\n    promise.finally(() => this.inflight.delete(promise))\n  }\n\n  async close(): Promise<void> {\n    await Promise.allSettled(Array.from(this.inflight))\n  }\n}\n\n/** Fanout to multiple sinks — failures in one do not affect others. */\nexport class FanoutTelemetrySink implements TelemetrySink {\n  constructor(private readonly sinks: TelemetrySink[]) {}\n\n  emit(envelope: TelemetryEnvelope): void {\n    for (const sink of this.sinks) {\n      try {\n        const result = sink.emit(envelope)\n        if (result && typeof (result as Promise<unknown>).catch === 'function') {\n          ;(result as Promise<unknown>).catch(() => undefined)\n        }\n      } catch {\n        // swallow — telemetry must never break a run\n      }\n    }\n  }\n\n  async close(): Promise<void> {\n    await Promise.allSettled(this.sinks.map((s) => Promise.resolve(s.close?.())))\n  }\n}\n\n/** No-op sink — used when telemetry is explicitly disabled. */\nexport class NullTelemetrySink implements TelemetrySink {\n  emit(): void {}\n}\n\n/** In-memory sink — useful for tests + downstream adapters. */\nexport class InMemoryTelemetrySink implements TelemetrySink {\n  readonly envelopes: TelemetryEnvelope[] = []\n  emit(envelope: TelemetryEnvelope): void {\n    this.envelopes.push(envelope)\n  }\n  clear(): void {\n    this.envelopes.length = 0\n  }\n}\n"],"mappings":";;;AAYO,IAAM,2BAA2B;;;ACgBjC,IAAM,kBAAN,MAAsB;AAAA,EAC3B,YACmB,MACA,eACjB;AAFiB;AACA;AAAA,EAChB;AAAA,EAFgB;AAAA,EACA;AAAA,EAGnB,KAAK,MAAsB;AACzB,UAAM,WAA8B;AAAA,MAClC,eAAe;AAAA,MACf,YAAY,eAAe;AAAA,MAC3B,OAAO,KAAK;AAAA,MACZ,YAAW,oBAAI,KAAK,GAAE,YAAY;AAAA,MAClC,QAAQ,KAAK,UAAU,KAAK;AAAA,MAC5B,MAAM,KAAK;AAAA,MACX,IAAI,KAAK;AAAA,MACT,YAAY,KAAK;AAAA,MACjB,MAAM,KAAK,QAAQ,CAAC;AAAA,MACpB,SAAS,KAAK,WAAW,CAAC;AAAA,MAC1B,GAAI,KAAK,cAAc,EAAE,aAAa,KAAK,YAAY,IAAI,CAAC;AAAA,MAC5D,GAAI,KAAK,QAAQ,EAAE,OAAO,KAAK,MAAM,IAAI,CAAC;AAAA,MAC1C,GAAI,KAAK,OAAO,EAAE,MAAM,KAAK,KAAK,IAAI,CAAC;AAAA,MACvC,GAAI,KAAK,QAAQ,EAAE,OAAO,KAAK,MAAM,IAAI,CAAC;AAAA,IAC5C;AACA,QAAI;AACF,WAAK,KAAK,KAAK,QAAQ;AAAA,IACzB,QAAQ;AAAA,IAER;AAAA,EACF;AAAA,EAEA,MAAM,QAAuB;AAC3B,UAAM,KAAK,KAAK,QAAQ;AAAA,EAC1B;AACF;AAGA,SAAS,iBAAyB;AAChC,MAAI,OAAO,WAAW,eAAe,OAAO,OAAO,eAAe,YAAY;AAC5E,WAAO,OAAO,WAAW;AAAA,EAC3B;AAEA,SAAO,OAAO,KAAK,IAAI,EAAE,SAAS,EAAE,CAAC,IAAI,KAAK,OAAO,EAAE,SAAS,EAAE,EAAE,MAAM,GAAG,EAAE,CAAC;AAClF;AAEO,IAAM,eAAe,oBAAI,IAAI,CAAC,aAAa,YAAY,WAAW,YAAY,CAAC;AAG/E,SAAS,aAAa,MAA0B;AACrD,QAAM,MAAgB,CAAC;AACvB,WAAS,IAAI,GAAG,IAAI,KAAK,QAAQ,KAAK;AACpC,UAAM,IAAI,KAAK,CAAC;AAChB,QAAI,aAAa,IAAI,CAAC,GAAG;AACvB,UAAI,KAAK,GAAG,YAAY;AACxB;AACA;AAAA,IACF;AACA,QAAI,8CAA8C,KAAK,CAAC,GAAG;AACzD,UAAI,KAAK,EAAE,QAAQ,QAAQ,aAAa,CAAC;AACzC;AAAA,IACF;AACA,QAAI,KAAK,CAAC;AAAA,EACZ;AACA,SAAO;AACT;;;AC3EO,IAAM,oBAAN,MAAiD;AAAA,EAGtD,YACmB,UACA,QACjB;AAFiB;AACA;AAAA,EAChB;AAAA,EAFgB;AAAA,EACA;AAAA,EAJX,WAAW,oBAAI,IAAmB;AAAA,EAO1C,KAAK,UAAmC;AACtC,UAAM,OAAO,KAAK,UAAU,QAAQ;AACpC,UAAM,UAAkC,EAAE,gBAAgB,mBAAmB;AAC7E,QAAI,KAAK,OAAQ,SAAQ,gBAAgB,UAAU,KAAK,MAAM;AAC9D,UAAM,UAAU,MAAM,KAAK,UAAU,EAAE,QAAQ,QAAQ,SAAS,KAAK,CAAC,EACnE,KAAK,MAAM,MAAS,EACpB,MAAM,MAAM,MAAS;AACxB,SAAK,SAAS,IAAI,OAAO;AACzB,YAAQ,QAAQ,MAAM,KAAK,SAAS,OAAO,OAAO,CAAC;AAAA,EACrD;AAAA,EAEA,MAAM,QAAuB;AAC3B,UAAM,QAAQ,WAAW,MAAM,KAAK,KAAK,QAAQ,CAAC;AAAA,EACpD;AACF;AAGO,IAAM,sBAAN,MAAmD;AAAA,EACxD,YAA6B,OAAwB;AAAxB;AAAA,EAAyB;AAAA,EAAzB;AAAA,EAE7B,KAAK,UAAmC;AACtC,eAAW,QAAQ,KAAK,OAAO;AAC7B,UAAI;AACF,cAAM,SAAS,KAAK,KAAK,QAAQ;AACjC,YAAI,UAAU,OAAQ,OAA4B,UAAU,YAAY;AACtE;AAAC,UAAC,OAA4B,MAAM,MAAM,MAAS;AAAA,QACrD;AAAA,MACF,QAAQ;AAAA,MAER;AAAA,IACF;AAAA,EACF;AAAA,EAEA,MAAM,QAAuB;AAC3B,UAAM,QAAQ,WAAW,KAAK,MAAM,IAAI,CAAC,MAAM,QAAQ,QAAQ,EAAE,QAAQ,CAAC,CAAC,CAAC;AAAA,EAC9E;AACF;AAGO,IAAM,oBAAN,MAAiD;AAAA,EACtD,OAAa;AAAA,EAAC;AAChB;AAGO,IAAM,wBAAN,MAAqD;AAAA,EACjD,YAAiC,CAAC;AAAA,EAC3C,KAAK,UAAmC;AACtC,SAAK,UAAU,KAAK,QAAQ;AAAA,EAC9B;AAAA,EACA,QAAc;AACZ,SAAK,UAAU,SAAS;AAAA,EAC1B;AACF;","names":[]}

package/dist/testing-C21CHsq2.d.ts

@@ -1,20 +0,0 @@
-/**
- * LockedJsonlAppender — mutex-serialized JSONL append helper for arbitrary
- * payloads. The reference-replay store does the same thing for typed
- * `ReferenceReplayRun` rows; this is the generic version used by
- * `MutationTelemetry`, `TrialTelemetry`, and any other consumer that wants
- * append-only durable telemetry without rolling its own lock.
- *
- * Locks are per absolute file path (process-local). Cross-process
- * concurrency is NOT addressed — that's an fcntl/flock problem.
- */
-declare class LockedJsonlAppender {
-    readonly path: string;
-    private readonly mutex;
-    constructor(path: string);
-    append(entry: unknown): Promise<void>;
-}
-/** Reset all internal mutex state — tests only. */
-declare function resetLockedAppendersForTesting(): void;
-
-export { LockedJsonlAppender as L, resetLockedAppendersForTesting as r };

package/dist/testing.d.ts

@@ -1 +0,0 @@
-export { r as resetLockedAppendersForTesting } from './testing-C21CHsq2.js';