@tangle-network/agent-eval 0.95.0 → 0.95.1

package/dist/telemetry/index.d.ts

@@ -1,20 +1,38 @@
+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';
+
 /**
- * Public entry for the telemetry sub-module.
+ * 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.
  *
- * Workers-safe by default — only `fetch` + pure JS. The Node file sink is
- * exported separately via './telemetry/file' so consumers that import this entry
- * cannot accidentally pull `node:fs` into a Worker bundle.
- *
- * Consume:
- *   import { TelemetryClient, HttpTelemetrySink, FanoutTelemetrySink }
- *     from '@tangle-network/agent-eval/telemetry'
- *
- * For Node:
- *   import { FileTelemetrySink, defaultTelemetryDir }
- *     from '@tangle-network/agent-eval/telemetry/file'
+ * For an opinionated singleton with env-var-driven sink wiring (the bad CLI
+ * pattern), see `./node-client.ts`.
  */
-export { type EmitArgs, SECRET_FLAGS, sanitiseArgv, TelemetryClient, } from './client';
-export type { TelemetryEnvelope, TelemetryKind, TelemetryModel, TelemetrySource, } from './schema';
-export { TELEMETRY_SCHEMA_VERSION } from './schema';
-export { FanoutTelemetrySink, HttpTelemetrySink, InMemoryTelemetrySink, NullTelemetrySink, type TelemetrySink, } from './sink-fetch';
-//# sourceMappingURL=index.d.ts.map
+
+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/{sandbox-harness.d.ts → test-graded-scenario-DeODGLra.d.ts}

@@ -1,3 +1,7 @@
+import { T as TraceEmitter } from './emitter-C2rqGH_l.js';
+import { R as Run, F as FailureClass } from './schema-m0gsnbt3.js';
+import { T as TraceStore } from './store-BcFXE6LG.js';
+
 /**
  * SandboxHarness — executes a scenario in an isolated environment and
  * emits a rich SandboxSpan into the trace.
@@ -11,8 +15,8 @@
  * Consumers implement `SandboxDriver` for custom backends (Firecracker,
  * Cloudflare sandbox product, etc.). The harness doesn't care which.
  */
-import type { TraceEmitter } from './trace/emitter';
-export interface HarnessConfig {
+
+interface HarnessConfig {
     /** Setup command (e.g. "pnpm install"). Non-zero exit fails the run. */
     setupCommand?: string;
     /** Run command (e.g. "pnpm build"). */
@@ -36,14 +40,14 @@ export interface HarnessConfig {
     /** Parser for the test output — maps stdout/stderr/exit code → pass count. */
     testParser?: TestOutputParser;
 }
-export interface TestOutputParser {
+interface TestOutputParser {
     id: string;
     parse(stdout: string, stderr: string, exitCode: number): {
         testsTotal: number;
         testsPassed: number;
     } | undefined;
 }
-export interface SandboxResult {
+interface SandboxResult {
     phase: 'setup' | 'run' | 'test';
     exitCode: number;
     stdout: string;
@@ -65,19 +69,19 @@ export interface SandboxResult {
      */
     outputTruncated?: boolean;
 }
-export interface SandboxDriver {
+interface SandboxDriver {
     id: string;
     exec(phase: SandboxResult['phase'], command: string, config: HarnessConfig): Promise<SandboxResult>;
 }
 /** Vitest default summary line: "Tests  X passed | Y failed". */
-export declare const vitestTestParser: TestOutputParser;
+declare const vitestTestParser: TestOutputParser;
 /** Pytest default: "collected N items" + " X passed, Y failed". */
-export declare const pytestTestParser: TestOutputParser;
+declare const pytestTestParser: TestOutputParser;
 /** Jest: "Tests: X passed, Y total" (and optional failed). */
-export declare const jestTestParser: TestOutputParser;
+declare const jestTestParser: TestOutputParser;
 /** Composite parser — tries a list of parsers in order. */
-export declare function composeParsers(...parsers: TestOutputParser[]): TestOutputParser;
-export interface SubprocessSandboxDriverOptions {
+declare function composeParsers(...parsers: TestOutputParser[]): TestOutputParser;
+interface SubprocessSandboxDriverOptions {
     /**
      * Default cwd for all `exec` calls. Used when the per-call `HarnessConfig`
      * does not set its own `cwd`. Lets callers bind the driver to a working
@@ -93,18 +97,18 @@ export interface SubprocessSandboxDriverOptions {
      */
     env?: Record<string, string>;
 }
-export declare class SubprocessSandboxDriver implements SandboxDriver {
+declare class SubprocessSandboxDriver implements SandboxDriver {
     id: string;
     private defaultCwd?;
     private defaultEnv?;
     constructor(options?: SubprocessSandboxDriverOptions);
     exec(phase: SandboxResult['phase'], command: string, config: HarnessConfig): Promise<SandboxResult>;
 }
-export declare class DockerSandboxDriver implements SandboxDriver {
+declare class DockerSandboxDriver implements SandboxDriver {
     id: string;
     exec(phase: SandboxResult['phase'], command: string, config: HarnessConfig): Promise<SandboxResult>;
 }
-export interface SandboxHarnessResult {
+interface SandboxHarnessResult {
     passed: boolean;
     setup?: SandboxResult;
     run?: SandboxResult;
@@ -113,9 +117,50 @@ export interface SandboxHarnessResult {
     /** Final score — 0 when no tests; otherwise testsPassed/testsTotal. */
     score: number;
 }
-export declare class SandboxHarness {
+declare class SandboxHarness {
     private driver;
     constructor(driver?: SandboxDriver);
     run(config: HarnessConfig, emitter: TraceEmitter): Promise<SandboxHarnessResult>;
 }
-//# sourceMappingURL=sandbox-harness.d.ts.map
+
+/**
+ * TestGradedScenario — a scenario whose score comes from a test suite.
+ *
+ * This is the SWE-bench pattern generalized. The scenario ships:
+ *   - fixture data (setup instructions)
+ *   - a test command the harness runs
+ *   - optional assertion overrides
+ *
+ * The runner emits a run, delegates to SandboxHarness, records the
+ * outcome, and returns a structured verdict. Consumers bind their own
+ * agent execution to this contract.
+ */
+
+interface TestGradedScenario {
+    id: string;
+    description?: string;
+    harness: HarnessConfig;
+    /** Optional pass threshold in 0..1 (default 1.0 = all tests must pass). */
+    passThreshold?: number;
+    /** Provenance for dataset tracking. */
+    datasetVersion?: string;
+    /** Free-form tags (difficulty, category, etc.). */
+    tags?: Record<string, string>;
+}
+interface TestGradedRunOptions {
+    variantId?: string;
+    driver?: SandboxDriver;
+    /** Metadata recorded on the Run (codeSha, promptSha, modelFingerprint, seed). */
+    provenance?: Pick<Run, 'codeSha' | 'promptSha' | 'modelFingerprint' | 'seed' | 'envFingerprint'>;
+}
+interface TestGradedRunResult {
+    runId: string;
+    scenario: TestGradedScenario;
+    harness: SandboxHarnessResult;
+    pass: boolean;
+    score: number;
+    failureClass?: FailureClass;
+}
+declare function runTestGradedScenario(scenario: TestGradedScenario, store: TraceStore, options?: TestGradedRunOptions): Promise<TestGradedRunResult>;
+
+export { DockerSandboxDriver as D, type HarnessConfig as H, type SandboxDriver as S, type TestGradedScenario as T, type SandboxHarnessResult as a, type TestGradedRunResult as b, SandboxHarness as c, type SandboxResult as d, SubprocessSandboxDriver as e, type SubprocessSandboxDriverOptions as f, type TestGradedRunOptions as g, type TestOutputParser as h, composeParsers as i, jestTestParser as j, pytestTestParser as p, runTestGradedScenario as r, vitestTestParser as v };

package/dist/{locked-jsonl-appender.d.ts → testing-C21CHsq2.d.ts}

@@ -8,12 +8,13 @@
  * Locks are per absolute file path (process-local). Cross-process
  * concurrency is NOT addressed — that's an fcntl/flock problem.
  */
-export declare class LockedJsonlAppender {
+declare class LockedJsonlAppender {
     readonly path: string;
     private readonly mutex;
     constructor(path: string);
     append(entry: unknown): Promise<void>;
 }
 /** Reset all internal mutex state — tests only. */
-export declare function resetLockedAppendersForTesting(): void;
-//# sourceMappingURL=locked-jsonl-appender.d.ts.map
+declare function resetLockedAppendersForTesting(): void;
+
+export { LockedJsonlAppender as L, resetLockedAppendersForTesting as r };

package/dist/testing.d.ts

@@ -1,5 +1 @@
-/**
- * Testing-only helpers. Do not import this subpath from production code.
- */
-export { resetLockedAppendersForTesting } from './locked-jsonl-appender';
-//# sourceMappingURL=testing.d.ts.map
+export { r as resetLockedAppendersForTesting } from './testing-C21CHsq2.js';