@arizeai/phoenix-client 6.11.0 → 6.11.2

package/docs/ci-evals-vitest.mdx

@@ -90,7 +90,7 @@ px.describe("my suite", () => { ... }, {
 | `client` | `PhoenixClient` | Pre-configured `@arizeai/phoenix-client` instance. |
 | `repetitions` | `number` | Run each test in the suite this many times (default `1`; `PHOENIX_TEST_REPETITIONS` overrides the default). Per-test `repetitions` wins. |
 | `acceptanceCriteria` | `AcceptanceCriterion[]` | Aggregate annotation thresholds that fail the suite after all tests run. |
-| `dryRun` | `boolean` | Run the whole suite locally — no dataset, experiment, runs, or annotations are created in Phoenix. Same effect as `PHOENIX_TEST_TRACING=false`, scoped to this suite. |
+| `dryRun` | `boolean` | Run the whole suite locally — no dataset, experiment, runs, or annotations are created in Phoenix. Same effect as `PHOENIX_TEST_TRACKING=false`, scoped to this suite. |
 
 ### `test(name, params, fn, timeout?)`
 

package/docs/ci-evals.mdx

@@ -97,7 +97,7 @@ standard Phoenix env vars.
 | `PHOENIX_HOST` | Phoenix base URL |
 | `PHOENIX_API_KEY` | Bearer token for Phoenix |
 | `PHOENIX_CLIENT_HEADERS` | Optional JSON headers forwarded to the Phoenix client and tracer |
-| `PHOENIX_TEST_TRACING=false` | Disable sync to Phoenix for the current run (tracing is on by default) |
+| `PHOENIX_TEST_TRACKING=false` | Disable sync to Phoenix for the current run (tracing is on by default) |
 | `PHOENIX_TEST_REPETITIONS` | Default number of times to run each test |
 | `PHOENIX_TEST_REPORTER=verbose` | Show every test row plus per-test `output:` detail (default is the compact view) |
 | `PHOENIX_TEST_REPORTER_MAX_ROWS` | Max test rows shown per suite in compact mode (default `10`; failures are never hidden) |
@@ -123,7 +123,7 @@ Dry-run executes test bodies (and tracing, when a tracer is attached) but
 creates no dataset, experiment, run, or annotations in Phoenix. The
 reporter still prints a local summary.
 
-- **Whole process** — `PHOENIX_TEST_TRACING=false`.
+- **Whole process** — `PHOENIX_TEST_TRACKING=false`.
 - **One suite** — `describe(name, fn, { dryRun: true })`.
 - **One test** — `test(name, { input, dryRun: true }, fn)`; that case runs
   as an ordinary local test, with no dataset example and nothing uploaded,

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@arizeai/phoenix-client",
-  "version": "6.11.0",
+  "version": "6.11.2",
   "description": "A client for the Phoenix API",
   "keywords": [
     "arize",
@@ -96,7 +96,7 @@
   },
   "dependencies": {
     "@arizeai/openinference-semantic-conventions": "^2.5.0",
-    "@arizeai/openinference-vercel": "^2.7.8",
+    "@arizeai/openinference-vercel": "^2.8.1",
     "async": "^3.2.6",
     "openapi-fetch": "^0.17.0",
     "tiny-invariant": "^1.3.3",
@@ -105,16 +105,16 @@
     "@arizeai/phoenix-otel": "1.0.2"
   },
   "devDependencies": {
-    "@ai-sdk/openai": "^3.0.73",
+    "@ai-sdk/openai": "^3.0.75",
     "@anthropic-ai/sdk": "^0.102.0",
     "@opentelemetry/api": "^1.9.1",
     "@opentelemetry/sdk-trace-node": "^2.8.0",
     "@types/async": "^3.2.25",
     "@types/node": "^25.9.4",
-    "ai": "^6.0.208",
-    "dotenv": "^16.4.7",
+    "ai": "^6.0.211",
+    "dotenv": "^16.6.1",
     "jest": "^29.7.0",
-    "openai": "^6.44.0",
+    "openai": "^6.45.0",
     "openapi-typescript": "^7.13.0",
     "tsx": "^4.22.4",
     "vitest": "^4.1.9",

package/src/__generated__/api/v1.ts

@@ -1298,6 +1298,40 @@ export interface paths {
         patch?: never;
         trace?: never;
     };
+    "/agents/server/sessions/{session_id}/chat": {
+        parameters: {
+            query?: never;
+            header?: never;
+            path?: never;
+            cookie?: never;
+        };
+        get?: never;
+        put?: never;
+        /**
+         * Run Server Agent
+         * @description Stream a chat turn from the GraphQL server agent.
+         *
+         *     This is the endpoint the PXI CLI talks to directly (no pre-configured
+         *     agent record): it builds a fresh server agent per request from the
+         *     caller-supplied model and contexts, then streams the reply back as
+         *     Vercel-AI chunks.
+         *
+         *     The request contexts gate capabilities — GraphQL mutations, web access,
+         *     and subagents — and mutations are refused for viewer users. When trace
+         *     recording is enabled (and permitted by system settings), the run is
+         *     traced; locally ingested traces are persisted to the agent's project
+         *     once the stream completes.
+         *
+         *     Returns ``403`` if agents or the server agent are disabled, or if a
+         *     viewer requests mutations.
+         */
+        post: operations["run_server_agent_agents_server_sessions__session_id__chat_post"];
+        delete?: never;
+        options?: never;
+        head?: never;
+        patch?: never;
+        trace?: never;
+    };
     "/agents/{agent_id}/sessions/{session_id}/chat": {
         parameters: {
             query?: never;
@@ -9288,6 +9322,41 @@ export interface operations {
             };
         };
     };
+    run_server_agent_agents_server_sessions__session_id__chat_post: {
+        parameters: {
+            query?: never;
+            header?: never;
+            path: {
+                session_id: string;
+            };
+            cookie?: never;
+        };
+        requestBody: {
+            content: {
+                "application/json": components["schemas"]["ChatRequest"];
+            };
+        };
+        responses: {
+            /** @description Successful Response */
+            200: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": unknown;
+                };
+            };
+            /** @description Validation Error */
+            422: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": components["schemas"]["HTTPValidationError"];
+                };
+            };
+        };
+    };
     chat_agents__agent_id__sessions__session_id__chat_post: {
         parameters: {
             query?: never;

package/src/testing/phoenix-test-tracking.ts

@@ -28,23 +28,67 @@ import {
 import { currentRun, type RunState, type SuiteState } from "./state";
 import type { Annotation, KVMap } from "./types";
 
-function isFalsyFlag(value: string | undefined): boolean {
-  const v = (value ?? "").toLowerCase();
+export function isFalsyFlag(value: string | undefined): boolean {
+  // Tolerate surrounding whitespace and matching quotes that survive some
+  // shells and `.env` loaders (e.g. `PHOENIX_TEST_TRACKING="false"` or a value
+  // with a trailing newline). Without this, such a value reads as truthy and
+  // silently re-enables recording even though the user asked to disable it.
+  const v = (value ?? "")
+    .trim()
+    .replace(/^(['"])(.*)\1$/, "$2")
+    .trim()
+    .toLowerCase();
   return v === "false" || v === "0" || v === "off" || v === "no";
 }
 
+/**
+ * Snapshot of `PHOENIX_TEST_TRACKING` as it was when this module first loaded.
+ *
+ * When the flag is exported on the command line (the documented `eval:offline`
+ * workflow), this captures the user's intent at process start and is immune to
+ * any later in-process mutation of `process.env` by a sibling suite or setup
+ * file. That mutation is what made tracking leak across suites in #13930: one
+ * suite flipped the env var and re-enabled recording for the others.
+ */
+const trackingDisabledAtLoad = isFalsyFlag(process.env.PHOENIX_TEST_TRACKING);
+
+/**
+ * Latches to `true` the first time tracking is observed disabled in this
+ * process. Recording is opt-out and shared process-wide, so a single falsy
+ * reading turns the whole run off and keeps it off — later suites cannot
+ * re-enable recording regardless of declaration or execution order.
+ */
+let trackingLatchedOff = trackingDisabledAtLoad;
+
+/**
+ * Reset the process-level tracking latch. Test-only seam so unit tests can
+ * exercise the enable/disable transitions in isolation; not part of the
+ * public API.
+ *
+ * @internal
+ */
+export function __resetTrackingLatchForTests(): void {
+  trackingLatchedOff = isFalsyFlag(process.env.PHOENIX_TEST_TRACKING);
+}
+
 /**
  * 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`.
+ * `PHOENIX_TEST_TRACKING=false`, or per suite via `SuiteConfig.dryRun`.
+ *
+ * The global disable is sticky for the lifetime of the process: once the flag
+ * is seen falsy — at load time or on any later call — tracking stays off for
+ * every suite. This keeps offline mode deterministic regardless of which
+ * suites are included in a run, or the order they execute in.
  */
 export function isTrackingEnabled(suite?: SuiteState): {
   enabled: boolean;
   reason?: string;
 } {
-  if (isFalsyFlag(process.env.PHOENIX_TEST_TRACING)) {
-    return { enabled: false, reason: "PHOENIX_TEST_TRACING is disabled" };
+  if (trackingLatchedOff || isFalsyFlag(process.env.PHOENIX_TEST_TRACKING)) {
+    trackingLatchedOff = true;
+    return { enabled: false, reason: "PHOENIX_TEST_TRACKING is disabled" };
   }
   if (suite?.config.dryRun) {
     return { enabled: false, reason: "suite configured dryRun" };
@@ -177,7 +221,7 @@ function buildLinks(
  * 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),
+ * If tracing is disabled (no Phoenix env vars, or PHOENIX_TEST_TRACKING=false),
  * this populates a no-op tracer and exits without making any network calls.
  */
 export async function initializeSuite(suite: SuiteState): Promise<void> {
@@ -478,6 +522,7 @@ export async function postExperimentRun(
   if (
     run.dryRun ||
     suite.trackingDisabled ||
+    !isTrackingEnabled(suite).enabled ||
     !suite.client ||
     !suite.experimentId
   ) {
@@ -524,7 +569,13 @@ export async function postAnnotation(
   runId: string | undefined,
   annotation: Annotation
 ): Promise<void> {
-  if (suite.trackingDisabled || !suite.client || !runId) return;
+  if (
+    suite.trackingDisabled ||
+    !isTrackingEnabled(suite).enabled ||
+    !suite.client ||
+    !runId
+  )
+    return;
   const start = new Date();
   const end = new Date();
   try {

package/src/testing/runner.ts

@@ -148,7 +148,7 @@ export function declareTest<Input extends KVMap, Expected extends KVMap>(
 
   // A per-test `dryRun` opts the case out of Phoenix entirely: no dataset
   // example, no experiment run, no annotations — it runs as an ordinary
-  // local test. Suite-level dryRun (or PHOENIX_TEST_TRACING=false) is
+  // local test. Suite-level dryRun (or PHOENIX_TEST_TRACKING=false) is
   // handled in `initializeSuite`, which never uploads anything anyway.
   const isDryRun = !!params.dryRun;
 

package/src/testing/types.ts

@@ -241,7 +241,7 @@ export interface SuiteConfig {
   /**
    * When `true`, the whole suite runs as ordinary local tests — no dataset
    * is uploaded and no experiment, runs, or annotations are created in
-   * Phoenix. Equivalent to `PHOENIX_TEST_TRACING=false` scoped to this
+   * Phoenix. Equivalent to `PHOENIX_TEST_TRACKING=false` scoped to this
    * suite. The reporter still prints a local summary.
    */
   dryRun?: boolean;