@arizeai/phoenix-client 7.11.0 → 7.12.0

package/CHANGELOG.md

@@ -1,5 +1,11 @@
 # @arizeai/phoenix-client
 
+## 7.12.0
+
+### Minor Changes
+
+- dab09f1: Add `filter` expressions to `getTraces` and `listSessions` (requires Phoenix server >= 20.12.0). Deprecate the individual trace error and latency parameters while retaining their behavior and support for server >= 20.8.0.
+
 ## 7.11.0
 
 ### Minor Changes

package/README.md

@@ -383,8 +383,11 @@ checks an aggregate bar (so CI can allow a mean of 80% while still running
 every case), and `passRate` requires a minimum fraction of runs to satisfy a
 per-run `passFn` predicate.
 
-See the [`docs/`](./docs) folder — `ci-evals.mdx`, `ci-evals-vitest.mdx`,
-`ci-evals-jest.mdx`, and `ci-evals-annotations.mdx` — for setup, the full
+See the [CI Eval Tests](https://arize.com/docs/phoenix/sdk-api-reference/typescript/packages/phoenix-client/ci-evals),
+[Vitest](https://arize.com/docs/phoenix/sdk-api-reference/typescript/packages/phoenix-client/ci-evals-vitest),
+[Jest](https://arize.com/docs/phoenix/sdk-api-reference/typescript/packages/phoenix-client/ci-evals-jest),
+and [Annotations](https://arize.com/docs/phoenix/sdk-api-reference/typescript/packages/phoenix-client/ci-evals-annotations)
+guides for setup, the full
 `describe` / `test` / `test.each` API, acceptance criteria, repetitions,
 dry-run mode, and annotation details.
 
@@ -422,11 +425,10 @@ const sessionTraces = await getTraces({
   sessionId: "my-session-id",
 });
 
-// Filter by error status and latency (requires Phoenix server >= 20.8.0)
+// Filter by error status and latency (requires Phoenix server >= 20.12.0)
 const slowFailures = await getTraces({
   project: { projectName: "my-project" },
-  error: true,
-  minLatencyMs: 1000,
+  filter: "error_count > 0 and latency_ms >= 1000",
 });
 ```
 
@@ -441,10 +443,16 @@ const slowFailures = await getTraces({
 | `cursor`       | `string \| null`               | Pagination cursor                                            |
 | `includeSpans` | `boolean`                      | Include full span details for each trace                     |
 | `sessionId`    | `string \| string[] \| null`   | Filter traces by session identifier(s)                       |
+| `filter`       | `string \| null`               | Trace filter expression                                      |
 | `error`        | `boolean \| null`              | Only traces with (`true`) or without (`false`) errored spans |
 | `minLatencyMs` | `number \| null`               | Inclusive lower bound on trace latency (ms)                  |
 | `maxLatencyMs` | `number \| null`               | Inclusive upper bound on trace latency (ms)                  |
 
+`error`, `minLatencyMs`, and `maxLatencyMs` are deprecated but remain supported on
+server >= 20.8.0. Use `error_count > 0` / `error_count == 0`, `latency_ms >= N`, and
+`latency_ms <= N` in `filter` instead. Empty expressions do not filter; invalid
+expressions return HTTP 400. Keep the same expression when requesting the next page.
+
 ### Pagination
 
 Use the `cursor` from a previous result to fetch the next page:

package/dist/esm/__generated__/api/v1.d.ts

@@ -429,7 +429,8 @@ export interface paths {
             path?: never;
             cookie?: never;
         };
-        get?: never;
+        /** List dataset splits */
+        get: operations["listDatasetSplits"];
         put?: never;
         /** Create a dataset split */
         post: operations["createDatasetSplit"];
@@ -3979,6 +3980,13 @@ export interface components {
             /** Data */
             data: components["schemas"]["DatasetLabel"][];
         };
+        /** ListDatasetSplitsResponseBody */
+        ListDatasetSplitsResponseBody: {
+            /** Data */
+            data: components["schemas"]["DatasetSplit"][];
+            /** Next Cursor */
+            next_cursor: string | null;
+        };
         /** ListDatasetVersionsResponseBody */
         ListDatasetVersionsResponseBody: {
             /** Data */
@@ -8958,6 +8966,61 @@ export interface operations {
             };
         };
     };
+    listDatasetSplits: {
+        parameters: {
+            query?: {
+                /** @description Cursor for pagination */
+                cursor?: string | null;
+                /** @description The max number of dataset splits to return at a time. */
+                limit?: number;
+            };
+            header?: never;
+            path: {
+                /** @description The dataset identifier: either dataset ID or dataset name. */
+                dataset_identifier: string;
+            };
+            cookie?: never;
+        };
+        requestBody?: never;
+        responses: {
+            /** @description Successful Response */
+            200: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": components["schemas"]["ListDatasetSplitsResponseBody"];
+                };
+            };
+            /** @description Forbidden */
+            403: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "text/plain": string;
+                };
+            };
+            /** @description Dataset not found */
+            404: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "text/plain": string;
+                };
+            };
+            /** @description Invalid request */
+            422: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "text/plain": string;
+                };
+            };
+        };
+    };
     createDatasetSplit: {
         parameters: {
             query?: never;
@@ -10111,12 +10174,23 @@ export interface operations {
                 include_spans?: boolean;
                 /** @description List of session identifiers to filter traces by. Each value can be either a session_id string or a session GlobalID. Only traces belonging to the specified sessions will be returned. */
                 session_identifier?: string[] | null;
-                /** @description Filter by trace error status. If true, only return traces that contain at least one span with `status_code == ERROR`. If false, only return traces with no errored spans. If omitted, traces are not filtered by error status. Matches the error indicator shown in the UI. */
+                /**
+                 * @deprecated
+                 * @description Deprecated: use `filter=error_count > 0` or `filter=error_count == 0`. Filter by trace error status. If true, only return traces that contain at least one span with `status_code == ERROR`. If false, only return traces with no errored spans. If omitted, traces are not filtered by error status.
+                 */
                 error?: boolean | null;
-                /** @description Inclusive lower bound on trace latency in milliseconds. */
+                /**
+                 * @deprecated
+                 * @description Inclusive lower bound on trace latency in milliseconds. Deprecated: use `filter=latency_ms >= N`.
+                 */
                 min_latency_ms?: number | null;
-                /** @description Inclusive upper bound on trace latency in milliseconds. */
+                /**
+                 * @deprecated
+                 * @description Inclusive upper bound on trace latency in milliseconds. Deprecated: use `filter=latency_ms <= N`.
+                 */
                 max_latency_ms?: number | null;
+                /** @description Trace filter expression, as documented at https://arize.com/docs/phoenix/tracing/how-to-tracing/filter-expressions. Combined with other filters using AND. Empty expressions do not filter. Invalid expressions return 400. */
+                filter?: string | null;
             };
             header?: never;
             path: {
@@ -10136,6 +10210,15 @@ export interface operations {
                     "application/json": components["schemas"]["GetTracesResponseBody"];
                 };
             };
+            /** @description Bad Request */
+            400: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "text/plain": string;
+                };
+            };
             /** @description Forbidden */
             403: {
                 headers: {
@@ -11903,6 +11986,8 @@ export interface operations {
                 limit?: number;
                 /** @description Sort order by ID: 'asc' (ascending) or 'desc' (descending). */
                 order?: "asc" | "desc";
+                /** @description Session filter expression, as documented at https://arize.com/docs/phoenix/tracing/how-to-tracing/filter-expressions. Empty expressions do not filter. Invalid expressions return 400. */
+                filter?: string | null;
             };
             header?: never;
             path: {
@@ -11922,6 +12007,15 @@ export interface operations {
                     "application/json": components["schemas"]["GetSessionsResponseBody"];
                 };
             };
+            /** @description Bad Request */
+            400: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "text/plain": string;
+                };
+            };
             /** @description Forbidden */
             403: {
                 headers: {