@arizeai/phoenix-client 6.10.0 → 6.11.0

package/dist/esm/testing/define-api.d.ts

@@ -0,0 +1,157 @@
+import { type RunnerHooks } from "./runner.js";
+import { type KVMap, type SuiteConfig, type TestEachRow, type TestFn, type TestParams } from "./types.js";
+/**
+ * Declare Phoenix eval test suites.
+ *
+ * Drop-in replacement for the test runner's own `describe`. The suite name
+ * doubles as the dataset and experiment name on the Phoenix server, and the
+ * optional {@link SuiteConfig} controls dataset naming, repetitions, dry-run
+ * mode, and CI acceptance criteria.
+ *
+ * @example
+ * ```ts
+ * import * as px from "@arizeai/phoenix-client/vitest";
+ *
+ * px.describe("generate sql demo", () => {
+ *   px.test("offtopic input", { input: { question: "hi" } }, async ({ input }) => {
+ *     // ...
+ *   });
+ * }, { metadata: { model: "gpt-4o-mini" } });
+ * ```
+ */
+export interface PhoenixDescribe {
+    /**
+     * Declare a Phoenix eval test suite.
+     *
+     * @param name - Suite name; doubles as the dataset / experiment name on Phoenix.
+     * @param fn - Suite body that declares its `test` / `it` cases.
+     * @param config - Optional suite-level config (dataset name, repetitions, dry-run, acceptance criteria).
+     */
+    (name: string, fn: () => void, config?: SuiteConfig): void;
+    /**
+     * Run only this suite, skipping all sibling suites
+     * (matches the runner's `describe.only`).
+     *
+     * @param name - Suite name; doubles as the dataset / experiment name on Phoenix.
+     * @param fn - Suite body that declares its `test` / `it` cases.
+     * @param config - Optional suite-level config.
+     */
+    only(name: string, fn: () => void, config?: SuiteConfig): void;
+    /**
+     * Skip this suite entirely (matches the runner's `describe.skip`). No dataset
+     * or experiment is created on Phoenix.
+     *
+     * @param name - Suite name; doubles as the dataset / experiment name on Phoenix.
+     * @param fn - Suite body (not executed).
+     * @param config - Optional suite-level config.
+     */
+    skip(name: string, fn: () => void, config?: SuiteConfig): void;
+}
+/**
+ * The test body returned by {@link PhoenixTest.each} after a table is bound.
+ *
+ * @param name - Test name, or a template (`%i` / `%s` / `%j`), or a function
+ *   that derives the name from the row and its index.
+ * @param fn - The test handler, run once per row in the bound table.
+ * @param timeout - Optional per-test timeout in milliseconds.
+ */
+export type PhoenixTestEach<Input extends KVMap = KVMap, Expected extends KVMap = KVMap> = (name: string | ((row: TestEachRow<Input, Expected>, index: number) => string), fn: TestFn<Input, Expected>, timeout?: number) => void;
+/**
+ * Declare a single Phoenix eval test case.
+ *
+ * Drop-in replacement for the test runner's own `test` / `it`. The `params`
+ * argument carries the `input` and the reference output (`expected` /
+ * `reference` / `output`) that become the dataset example; whatever the handler
+ * returns (or passes to `logOutput()`) is recorded as the experiment run's
+ * output and made available to evaluators.
+ *
+ * `it` is the canonical alias for `test`; the two are identical.
+ *
+ * @example
+ * ```ts
+ * px.test(
+ *   "summarizes the article",
+ *   { input: { article }, expected: { summary } },
+ *   async ({ input, expected }) => {
+ *     const output = await summarize(input.article);
+ *     px.logOutput(output);
+ *     await px.evaluate({ name: "matches", evaluate: () => output === expected.summary });
+ *   }
+ * );
+ * ```
+ */
+export interface PhoenixTest {
+    /**
+     * Declare a single Phoenix eval test case.
+     *
+     * @param name - Test case name; doubles as the dataset example label.
+     * @param params - Inline `input` and reference output that become the dataset example.
+     * @param fn - Test handler; receives `{ input, expected, metadata }`.
+     * @param timeout - Optional per-test timeout in milliseconds.
+     */
+    <Input extends KVMap = KVMap, Expected extends KVMap = KVMap>(name: string, params: TestParams<Input, Expected>, fn: TestFn<Input, Expected>, timeout?: number): void;
+    /**
+     * Run only this test case, skipping its siblings
+     * (matches the runner's `test.only`).
+     *
+     * @param name - Test case name; doubles as the dataset example label.
+     * @param params - Inline `input` and reference output that become the dataset example.
+     * @param fn - Test handler; receives `{ input, expected, metadata }`.
+     * @param timeout - Optional per-test timeout in milliseconds.
+     */
+    only<Input extends KVMap = KVMap, Expected extends KVMap = KVMap>(name: string, params: TestParams<Input, Expected>, fn: TestFn<Input, Expected>, timeout?: number): void;
+    /**
+     * Skip this test case (matches the runner's `test.skip`). No dataset example
+     * or experiment run is created on Phoenix.
+     *
+     * @param name - Test case name; doubles as the dataset example label.
+     * @param params - Inline `input` and reference output (not used while skipped).
+     * @param fn - Test handler (not executed).
+     * @param timeout - Optional per-test timeout in milliseconds.
+     */
+    skip<Input extends KVMap = KVMap, Expected extends KVMap = KVMap>(name: string, params: TestParams<Input, Expected>, fn: TestFn<Input, Expected>, timeout?: number): void;
+    /**
+     * Run the same test handler across many examples. Returns a function that
+     * takes a name (or template / name-builder) and the shared test body; each
+     * row in `table` becomes its own dataset example and experiment run.
+     *
+     * @param table - Rows of `{ input, expected?, metadata?, ... }` to fan out over.
+     * @returns A {@link PhoenixTestEach} that binds the name and shared handler.
+     *
+     * @example
+     * ```ts
+     * px.test.each([
+     *   { input: { a: 1, b: 2 }, expected: { sum: 3 } },
+     *   { input: { a: 2, b: 2 }, expected: { sum: 4 } },
+     * ])("adds %j", async ({ input, expected }) => {
+     *   // ...
+     * });
+     * ```
+     */
+    each<Input extends KVMap, Expected extends KVMap>(table: TestEachRow<Input, Expected>[]): PhoenixTestEach<Input, Expected>;
+}
+/** The public testing surface returned by {@link createTestApi}. */
+export interface PhoenixTestApi {
+    /** Declare a Phoenix eval test suite. See {@link PhoenixDescribe}. */
+    describe: PhoenixDescribe;
+    /** Declare a Phoenix eval test case. See {@link PhoenixTest}. */
+    test: PhoenixTest;
+    /** Canonical alias for {@link PhoenixTestApi.test}. */
+    it: PhoenixTest;
+}
+/**
+ * Build the public `describe`/`test`/`it` API for a runner adapter.
+ *
+ * Both the jest and vitest entrypoints expose the identical surface; the only
+ * thing that differs between them is how the {@link RunnerHooks} are obtained
+ * (vitest imports them statically, jest resolves them lazily from globals).
+ * That difference is captured by `getHooks`, which is invoked once per
+ * declaration so adapters are free to resolve hooks lazily.
+ *
+ * The JSDoc that surfaces in editors lives on the {@link PhoenixDescribe} and
+ * {@link PhoenixTest} interfaces rather than the implementations below, so the
+ * docs survive the `export const { describe, test, it } = createTestApi(...)`
+ * destructuring in each adapter.
+ */
+export declare function createTestApi(getHooks: () => RunnerHooks): PhoenixTestApi;
+//# sourceMappingURL=define-api.d.ts.map

package/dist/esm/testing/define-api.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"define-api.d.ts","sourceRoot":"","sources":["../../../src/testing/define-api.ts"],"names":[],"mappings":"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"}

package/dist/esm/testing/define-api.js

@@ -0,0 +1,78 @@
+import { declareDescribe, declareTest } from "./runner.js";
+import { resolveReference, } from "./types.js";
+/**
+ * Build the public `describe`/`test`/`it` API for a runner adapter.
+ *
+ * Both the jest and vitest entrypoints expose the identical surface; the only
+ * thing that differs between them is how the {@link RunnerHooks} are obtained
+ * (vitest imports them statically, jest resolves them lazily from globals).
+ * That difference is captured by `getHooks`, which is invoked once per
+ * declaration so adapters are free to resolve hooks lazily.
+ *
+ * The JSDoc that surfaces in editors lives on the {@link PhoenixDescribe} and
+ * {@link PhoenixTest} interfaces rather than the implementations below, so the
+ * docs survive the `export const { describe, test, it } = createTestApi(...)`
+ * destructuring in each adapter.
+ */
+export function createTestApi(getHooks) {
+    const describe = ((name, fn, config) => {
+        declareDescribe(getHooks(), name, fn, config ?? {});
+    });
+    describe.only = (name, fn, config) => {
+        declareDescribe(getHooks(), name, fn, config ?? {}, "only");
+    };
+    describe.skip = (name, fn, config) => {
+        declareDescribe(getHooks(), name, fn, config ?? {}, "skip");
+    };
+    const test = ((name, params, fn, timeout) => {
+        declareTest(getHooks(), name, params, fn, "default", timeout);
+    });
+    test.only = (name, params, fn, timeout) => {
+        declareTest(getHooks(), name, params, fn, "only", timeout);
+    };
+    test.skip = (name, params, fn, timeout) => {
+        declareTest(getHooks(), name, params, fn, "skip", timeout);
+    };
+    test.each = (table) => {
+        return (name, fn, timeout) => {
+            table.forEach((row, i) => {
+                const testName = typeof name === "function"
+                    ? name(row, i)
+                    : interpolateName(name, row, i);
+                declareTest(getHooks(), testName, {
+                    id: row.id,
+                    input: row.input,
+                    expected: resolveReference(row),
+                    metadata: row.metadata,
+                    splits: row.splits,
+                    repetitions: row.repetitions,
+                    dryRun: row.dryRun,
+                }, fn, "default", timeout);
+            });
+        };
+    };
+    // `it` is the canonical alias for `test`.
+    const it = test;
+    return { describe, test, it };
+}
+/**
+ * Interpolate a `test.each` name template for a single row. Supports the
+ * common `%i`/`%s`/`%j` placeholders for surface parity with the underlying
+ * runners; when no placeholder is present the 1-based row index is appended.
+ */
+function interpolateName(name, row, index) {
+    if (!name.includes("%")) {
+        return `${name} #${index + 1}`;
+    }
+    const replacements = [
+        [/%i/g, String(index)],
+        [/%s/g, JSON.stringify(row.input)],
+        [/%j/g, JSON.stringify(row)],
+    ];
+    let out = name;
+    for (const [pattern, value] of replacements) {
+        out = out.replace(pattern, value);
+    }
+    return out;
+}
+//# sourceMappingURL=define-api.js.map

package/dist/esm/testing/define-api.js.map

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

package/dist/esm/testing/helpers.d.ts

@@ -0,0 +1,55 @@
+import { type SuiteState } from "./state.js";
+import type { Annotation, EvaluationParams, EvaluationResult, Evaluator, KVMap } from "./types.js";
+/**
+ * Log the output produced by the test for the current run.
+ *
+ * Calling this multiple times overwrites the previously recorded value.
+ * The argument can be any JSON-serializable value — typically an object
+ * matching the shape of the example's `expected` field.
+ */
+export declare function logOutput(output: unknown): void;
+/**
+ * Record an annotation on the current run.
+ *
+ * Annotations are collected during the test and posted to Phoenix as
+ * experiment evaluations after the test completes. The `name` is the
+ * Phoenix evaluation name; `score`, `label`, and `explanation` map to
+ * the standard Phoenix `EvaluationResult` fields.
+ *
+ * The annotation name `"pass"` is reserved — Phoenix eval tests always write
+ * a `pass` annotation derived from the test's assertion outcome, so a
+ * user-supplied annotation with that name would race / overwrite the
+ * built-in one. Such calls are silently ignored.
+ */
+export declare function logAnnotation(annotation: Annotation): void;
+/**
+ * Run an evaluator object against the current test run and record the result.
+ *
+ * The evaluator may come from `@arizeai/phoenix-evals.createEvaluator`,
+ * `asExperimentEvaluator`, or any plain object with `{ name, evaluate }`.
+ * When `params` is omitted, the current test's `input`, recorded `output`,
+ * `expected`, `metadata`, and task `traceId` are supplied.
+ */
+export declare function evaluate<Params extends KVMap = EvaluationParams & KVMap, Result = EvaluationResult>(evaluator: Evaluator<Params, Result>, params?: Partial<Params> & KVMap): Promise<Result>;
+/**
+ * Trace an evaluator function so its execution shows up as a separate
+ * `EVALUATOR` span in Phoenix and any `{ name, score }`-shaped return
+ * value is automatically captured as an annotation on the current run.
+ *
+ * The annotation name defaults to the traced function's name, falling
+ * back to `"evaluator"`.
+ */
+export declare function traceEvaluator<EvaluatorParams extends KVMap, EvaluatorResult>(fn: (params: EvaluatorParams) => EvaluatorResult | Promise<EvaluatorResult>, options?: {
+    name?: string;
+}): (params: EvaluatorParams) => Promise<EvaluatorResult>;
+/**
+ * Internal: persist all collected annotations for the run.
+ *
+ * Phoenix's `experiment_evaluations` endpoint is keyed by
+ * `(experiment_run_id, name)` so two annotations with the same name on
+ * the same run race each other. We collapse duplicates by name (last
+ * wins) up front, which makes the final state deterministic; the
+ * remaining writes target distinct names, so they post in parallel.
+ */
+export declare function flushAnnotations(runId: string | undefined, annotations: Annotation[], suite: SuiteState): Promise<void>;
+//# sourceMappingURL=helpers.d.ts.map

package/dist/esm/testing/helpers.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"helpers.d.ts","sourceRoot":"","sources":["../../../src/testing/helpers.ts"],"names":[],"mappings":"AAKA,OAAO,EAAc,KAAK,UAAU,EAAE,MAAM,SAAS,CAAC;AACtD,OAAO,KAAK,EACV,UAAU,EACV,gBAAgB,EAChB,gBAAgB,EAEhB,SAAS,EACT,KAAK,EACN,MAAM,SAAS,CAAC;AAEjB;;;;;;GAMG;AACH,wBAAgB,SAAS,CAAC,MAAM,EAAE,OAAO,GAAG,IAAI,CAU/C;AAED;;;;;;;;;;;;GAYG;AACH,wBAAgB,aAAa,CAAC,UAAU,EAAE,UAAU,GAAG,IAAI,CAS1D;AAED;;;;;;;GAOG;AACH,wBAAsB,QAAQ,CAC5B,MAAM,SAAS,KAAK,GAAG,gBAAgB,GAAG,KAAK,EAC/C,MAAM,GAAG,gBAAgB,EAEzB,SAAS,EAAE,SAAS,CAAC,MAAM,EAAE,MAAM,CAAC,EACpC,MAAM,CAAC,EAAE,OAAO,CAAC,MAAM,CAAC,GAAG,KAAK,GAC/B,OAAO,CAAC,MAAM,CAAC,CAoCjB;AAED;;;;;;;GAOG;AACH,wBAAgB,cAAc,CAAC,eAAe,SAAS,KAAK,EAAE,eAAe,EAC3E,EAAE,EAAE,CAAC,MAAM,EAAE,eAAe,KAAK,eAAe,GAAG,OAAO,CAAC,eAAe,CAAC,EAC3E,OAAO,CAAC,EAAE;IAAE,IAAI,CAAC,EAAE,MAAM,CAAA;CAAE,GAC1B,CAAC,MAAM,EAAE,eAAe,KAAK,OAAO,CAAC,eAAe,CAAC,CAoBvD;AAqFD;;;;;;;;GAQG;AACH,wBAAsB,gBAAgB,CACpC,KAAK,EAAE,MAAM,GAAG,SAAS,EACzB,WAAW,EAAE,UAAU,EAAE,EACzB,KAAK,EAAE,UAAU,GAChB,OAAO,CAAC,IAAI,CAAC,CAWf"}

package/dist/esm/testing/helpers.js

@@ -0,0 +1,179 @@
+import { endTaskSpanForRun, postAnnotation, runEvaluatorWithTracing, } from "./phoenix-test-tracking.js";
+import { currentRun } from "./state.js";
+/**
+ * Log the output produced by the test for the current run.
+ *
+ * Calling this multiple times overwrites the previously recorded value.
+ * The argument can be any JSON-serializable value — typically an object
+ * matching the shape of the example's `expected` field.
+ */
+export function logOutput(output) {
+    const run = currentRun();
+    if (!run) {
+        throw new Error("logOutput() must be called inside a Phoenix eval test body");
+    }
+    run.output = output;
+    run.outputSet = true;
+    endTaskSpanForRun(run);
+}
+/**
+ * Record an annotation on the current run.
+ *
+ * Annotations are collected during the test and posted to Phoenix as
+ * experiment evaluations after the test completes. The `name` is the
+ * Phoenix evaluation name; `score`, `label`, and `explanation` map to
+ * the standard Phoenix `EvaluationResult` fields.
+ *
+ * The annotation name `"pass"` is reserved — Phoenix eval tests always write
+ * a `pass` annotation derived from the test's assertion outcome, so a
+ * user-supplied annotation with that name would race / overwrite the
+ * built-in one. Such calls are silently ignored.
+ */
+export function logAnnotation(annotation) {
+    const run = currentRun();
+    if (!run) {
+        throw new Error("logAnnotation() must be called inside a Phoenix eval test body");
+    }
+    if (annotation.name === "pass")
+        return;
+    run.annotations.push(annotation);
+}
+/**
+ * Run an evaluator object against the current test run and record the result.
+ *
+ * The evaluator may come from `@arizeai/phoenix-evals.createEvaluator`,
+ * `asExperimentEvaluator`, or any plain object with `{ name, evaluate }`.
+ * When `params` is omitted, the current test's `input`, recorded `output`,
+ * `expected`, `metadata`, and task `traceId` are supplied.
+ */
+export async function evaluate(evaluator, params) {
+    const run = currentRun();
+    if (!run) {
+        return await evaluator.evaluate((params ?? {}));
+    }
+    if (!run.outputSet && !(params && "output" in params)) {
+        warnEvaluateBeforeOutput(run.suite, evaluator.name, run.testName);
+    }
+    const evaluatorParams = {
+        input: run.params.input,
+        // `run.output` is only ever set together with `outputSet`, so it is already
+        // `undefined` until a value is recorded.
+        output: run.output,
+        expected: run.params.expected,
+        metadata: run.params.metadata,
+        traceId: run.traceId ?? null,
+        ...(params ?? {}),
+    };
+    const { result, traceId } = await runEvaluatorWithTracing(run.suite, evaluator.name, evaluatorParams, (paramsToEvaluate) => evaluator.evaluate(paramsToEvaluate));
+    logAnnotation(toAnnotation({
+        name: evaluator.name,
+        kind: evaluator.kind,
+        result,
+        traceId,
+    }));
+    return result;
+}
+/**
+ * Trace an evaluator function so its execution shows up as a separate
+ * `EVALUATOR` span in Phoenix and any `{ name, score }`-shaped return
+ * value is automatically captured as an annotation on the current run.
+ *
+ * The annotation name defaults to the traced function's name, falling
+ * back to `"evaluator"`.
+ */
+export function traceEvaluator(fn, options) {
+    const evaluatorName = options?.name ?? (fn.name && fn.name !== "" ? fn.name : "evaluator");
+    return async (params) => {
+        const run = currentRun();
+        if (!run) {
+            // outside a test context, just call the function plainly
+            return await fn(params);
+        }
+        const { result, traceId } = await runEvaluatorWithTracing(run.suite, evaluatorName, params, fn);
+        if (isAnnotationShaped(result)) {
+            logAnnotation({ ...result, traceId });
+        }
+        return result;
+    };
+}
+/**
+ * Warn (at most once per suite) when an evaluator runs before any output was
+ * recorded and none was passed explicitly. Such an evaluator receives
+ * `output: undefined`, which silently scores against nothing — almost always a
+ * forgotten `logOutput()`. Harmless for evaluators that only read `input`.
+ */
+const warnedOutputSuites = new WeakSet();
+function warnEvaluateBeforeOutput(suite, evaluatorName, testName) {
+    if (warnedOutputSuites.has(suite))
+        return;
+    warnedOutputSuites.add(suite);
+    // eslint-disable-next-line no-console
+    console.warn(`[@arizeai/phoenix-client] evaluate("${evaluatorName}") ran before ` +
+        `logOutput() on test "${testName}", so the evaluator received ` +
+        `output=undefined. Call logOutput(...) first, or pass { output } ` +
+        `explicitly. (Ignore if this evaluator only needs input.)`);
+}
+/**
+ * Normalize an evaluator's return value into an {@link Annotation}. The value
+ * is already typed as an {@link EvaluationResult}, so we only dispatch on its
+ * runtime shape: a string becomes a `label`, a number/boolean/null becomes a
+ * `score`, and an object contributes its `score`/`label`/`explanation`/
+ * `metadata` directly.
+ */
+function toAnnotation({ name, kind, result, traceId, }) {
+    const annotatorKind = kind ?? "CODE";
+    if (typeof result === "string") {
+        return { name, label: result, annotatorKind, traceId };
+    }
+    if (typeof result === "number" ||
+        typeof result === "boolean" ||
+        result === null) {
+        return { name, score: result, annotatorKind, traceId };
+    }
+    if (typeof result === "object" && !Array.isArray(result)) {
+        const { score, label, explanation, metadata } = result;
+        return {
+            name,
+            score,
+            label,
+            explanation,
+            metadata,
+            annotatorKind,
+            traceId,
+        };
+    }
+    return { name, annotatorKind, traceId };
+}
+function isAnnotationShaped(value) {
+    if (!value || typeof value !== "object")
+        return false;
+    const v = value;
+    if (typeof v.name !== "string")
+        return false;
+    if (v.score !== undefined &&
+        typeof v.score !== "number" &&
+        typeof v.score !== "boolean" &&
+        v.score !== null) {
+        return false;
+    }
+    return true;
+}
+/**
+ * Internal: persist all collected annotations for the run.
+ *
+ * Phoenix's `experiment_evaluations` endpoint is keyed by
+ * `(experiment_run_id, name)` so two annotations with the same name on
+ * the same run race each other. We collapse duplicates by name (last
+ * wins) up front, which makes the final state deterministic; the
+ * remaining writes target distinct names, so they post in parallel.
+ */
+export async function flushAnnotations(runId, annotations, suite) {
+    if (!annotations.length)
+        return;
+    const byName = new Map();
+    for (const annotation of annotations) {
+        byName.set(annotation.name, annotation);
+    }
+    await Promise.all(Array.from(byName.values(), (annotation) => postAnnotation(suite, runId, annotation)));
+}
+//# sourceMappingURL=helpers.js.map

package/dist/esm/testing/helpers.js.map

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

package/dist/esm/testing/phoenix-test-tracking.d.ts

@@ -0,0 +1,68 @@
+import { type GlobalTracerProviderRegistration, type NodeTracerProvider } from "@arizeai/phoenix-otel";
+import { type RunState, type SuiteState } from "./state.js";
+import type { Annotation, KVMap } from "./types.js";
+/**
+ * Decide whether tests should sync to Phoenix.
+ *
+ * Tracing is enabled by default. It can be disabled globally by setting
+ * `PHOENIX_TEST_TRACING=false`, or per suite via `SuiteConfig.dryRun`.
+ */
+export declare function isTrackingEnabled(suite?: SuiteState): {
+    enabled: boolean;
+    reason?: string;
+};
+/**
+ * Resolve the repetition count for a test: per-test value, else suite-level,
+ * else the `PHOENIX_TEST_REPETITIONS` env var, else `1`. Non-positive or
+ * non-finite values fall back to `1`.
+ */
+export declare function resolveRepetitions(perTest: number | undefined, suite: SuiteState): number;
+/**
+ * Initialize the suite: upload the dataset, create the experiment, and
+ * register the OpenInference tracer.
+ *
+ * If tracing is disabled (no Phoenix env vars, or PHOENIX_TEST_TRACING=false),
+ * this populates a no-op tracer and exits without making any network calls.
+ */
+export declare function initializeSuite(suite: SuiteState): Promise<void>;
+/**
+ * Wrap the user's test body in an OpenInference task span and return the
+ * trace id so we can submit it with the experiment run.
+ */
+export declare function runTaskWithTracing<Result>(suite: SuiteState, testName: string, fn: () => Promise<Result>): Promise<{
+    traceId: string;
+    result: Result;
+} | {
+    traceId: string;
+    error: Error;
+    isTaskError: boolean;
+}>;
+/**
+ * End the current run's task span. `logOutput()` calls this immediately so
+ * evaluator work that follows is not included in the task span duration.
+ */
+export declare function endTaskSpanForRun(run: RunState): void;
+/**
+ * POST a single experiment run for one test case to Phoenix.
+ *
+ * Best-effort: failures are captured and surfaced via the test reporter but
+ * do not fail the test itself.
+ */
+export declare function postExperimentRun(suite: SuiteState, run: RunState): Promise<string | undefined>;
+/**
+ * POST one annotation (an "experiment_evaluation") for a run.
+ */
+export declare function postAnnotation(suite: SuiteState, runId: string | undefined, annotation: Annotation): Promise<void>;
+/** Run an evaluator in an OpenInference evaluator span. */
+export declare function runEvaluatorWithTracing<EvaluatorParams extends KVMap, EvaluatorResult>(suite: SuiteState, name: string, params: EvaluatorParams, fn: (params: EvaluatorParams) => EvaluatorResult | Promise<EvaluatorResult>): Promise<{
+    result: EvaluatorResult;
+    traceId: string | null;
+}>;
+/**
+ * Tear down the tracer provider created for the suite, flushing any pending
+ * spans before the process exits.
+ */
+export declare function teardownSuite(suite: SuiteState): Promise<void>;
+/** Re-export the ones the entrypoint files consume. */
+export type { GlobalTracerProviderRegistration, NodeTracerProvider };
+//# sourceMappingURL=phoenix-test-tracking.d.ts.map

package/dist/esm/testing/phoenix-test-tracking.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"phoenix-test-tracking.d.ts","sourceRoot":"","sources":["../../../src/testing/phoenix-test-tracking.ts"],"names":[],"mappings":"AAAA,OAAO,EAIL,KAAK,gCAAgC,EAErC,KAAK,kBAAkB,EAQxB,MAAM,uBAAuB,CAAC;AAa/B,OAAO,EAAc,KAAK,QAAQ,EAAE,KAAK,UAAU,EAAE,MAAM,SAAS,CAAC;AACrE,OAAO,KAAK,EAAE,UAAU,EAAE,KAAK,EAAE,MAAM,SAAS,CAAC;AAOjD;;;;;GAKG;AACH,wBAAgB,iBAAiB,CAAC,KAAK,CAAC,EAAE,UAAU,GAAG;IACrD,OAAO,EAAE,OAAO,CAAC;IACjB,MAAM,CAAC,EAAE,MAAM,CAAC;CACjB,CAQA;AAED;;;;GAIG;AACH,wBAAgB,kBAAkB,CAChC,OAAO,EAAE,MAAM,GAAG,SAAS,EAC3B,KAAK,EAAE,UAAU,GAChB,MAAM,CAaR;AAoGD;;;;;;GAMG;AACH,wBAAsB,eAAe,CAAC,KAAK,EAAE,UAAU,GAAG,OAAO,CAAC,IAAI,CAAC,CAgKtE;AAeD;;;GAGG;AACH,wBAAsB,kBAAkB,CAAC,MAAM,EAC7C,KAAK,EAAE,UAAU,EACjB,QAAQ,EAAE,MAAM,EAChB,EAAE,EAAE,MAAM,OAAO,CAAC,MAAM,CAAC,GACxB,OAAO,CACN;IAAE,OAAO,EAAE,MAAM,CAAC;IAAC,MAAM,EAAE,MAAM,CAAA;CAAE,GACnC;IAAE,OAAO,EAAE,MAAM,CAAC;IAAC,KAAK,EAAE,KAAK,CAAC;IAAC,WAAW,EAAE,OAAO,CAAA;CAAE,CAC1D,CAiCA;AAMD;;;GAGG;AACH,wBAAgB,iBAAiB,CAAC,GAAG,EAAE,QAAQ,GAAG,IAAI,CAErD;AAsDD;;;;;GAKG;AACH,wBAAsB,iBAAiB,CACrC,KAAK,EAAE,UAAU,EACjB,GAAG,EAAE,QAAQ,GACZ,OAAO,CAAC,MAAM,GAAG,SAAS,CAAC,CAwC7B;AAED;;GAEG;AACH,wBAAsB,cAAc,CAClC,KAAK,EAAE,UAAU,EACjB,KAAK,EAAE,MAAM,GAAG,SAAS,EACzB,UAAU,EAAE,UAAU,GACrB,OAAO,CAAC,IAAI,CAAC,CAgCf;AAED,2DAA2D;AAC3D,wBAAsB,uBAAuB,CAC3C,eAAe,SAAS,KAAK,EAC7B,eAAe,EAEf,KAAK,EAAE,UAAU,EACjB,IAAI,EAAE,MAAM,EACZ,MAAM,EAAE,eAAe,EACvB,EAAE,EAAE,CAAC,MAAM,EAAE,eAAe,KAAK,eAAe,GAAG,OAAO,CAAC,eAAe,CAAC,GAC1E,OAAO,CAAC;IAAE,MAAM,EAAE,eAAe,CAAC;IAAC,OAAO,EAAE,MAAM,GAAG,IAAI,CAAA;CAAE,CAAC,CAiC9D;AAED;;;GAGG;AACH,wBAAsB,aAAa,CAAC,KAAK,EAAE,UAAU,GAAG,OAAO,CAAC,IAAI,CAAC,CAYpE;AAgBD,uDAAuD;AACvD,YAAY,EAAE,gCAAgC,EAAE,kBAAkB,EAAE,CAAC"}