@arizeai/phoenix-client 5.9.0 → 6.0.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@arizeai/phoenix-client",
-  "version": "5.9.0",
+  "version": "6.0.0",
   "description": "A client for the Phoenix API",
   "keywords": [
     "arize",
@@ -70,10 +70,9 @@
     "async": "^3.2.6",
     "openapi-fetch": "^0.12.5",
     "tiny-invariant": "^1.3.3",
-    "zod": "^3.24.3",
-    "zod-to-json-schema": "^3.24.3",
+    "zod": "^4.0.14",
     "@arizeai/phoenix-config": "0.1.1",
-    "@arizeai/phoenix-otel": "0.4.1"
+    "@arizeai/phoenix-otel": "0.4.2"
   },
   "devDependencies": {
     "@ai-sdk/openai": "^3.0.29",
@@ -85,7 +84,7 @@
     "openapi-typescript": "^7.6.1",
     "tsx": "^4.19.3",
     "vitest": "^4.0.10",
-    "@arizeai/phoenix-evals": "0.10.0"
+    "@arizeai/phoenix-evals": "1.0.0"
   },
   "optionalDependencies": {
     "@anthropic-ai/sdk": "^0.35.0",

package/src/__generated__/api/v1.ts

@@ -776,6 +776,40 @@ export interface paths {
         patch?: never;
         trace?: never;
     };
+    "/v1/sessions/{session_identifier}": {
+        parameters: {
+            query?: never;
+            header?: never;
+            path?: never;
+            cookie?: never;
+        };
+        /** Get session by ID or session_id */
+        get: operations["getSession"];
+        put?: never;
+        post?: never;
+        delete?: never;
+        options?: never;
+        head?: never;
+        patch?: never;
+        trace?: never;
+    };
+    "/v1/projects/{project_identifier}/sessions": {
+        parameters: {
+            query?: never;
+            header?: never;
+            path?: never;
+            cookie?: never;
+        };
+        /** List sessions for a project */
+        get: operations["listProjectSessions"];
+        put?: never;
+        post?: never;
+        delete?: never;
+        options?: never;
+        head?: never;
+        patch?: never;
+        trace?: never;
+    };
     "/v1/session_annotations": {
         parameters: {
             query?: never;
@@ -1481,6 +1515,17 @@ export interface components {
             /** Next Cursor */
             next_cursor: string | null;
         };
+        /** GetSessionResponseBody */
+        GetSessionResponseBody: {
+            data: components["schemas"]["SessionData"];
+        };
+        /** GetSessionsResponseBody */
+        GetSessionsResponseBody: {
+            /** Data */
+            data: components["schemas"]["SessionData"][];
+            /** Next Cursor */
+            next_cursor: string | null;
+        };
         /** GetUsersResponseBody */
         GetUsersResponseBody: {
             /** Data */
@@ -2515,6 +2560,44 @@ export interface components {
             /** Next Cursor */
             next_cursor: string | null;
         };
+        /** SessionData */
+        SessionData: {
+            /** Id */
+            id: string;
+            /** Session Id */
+            session_id: string;
+            /** Project Id */
+            project_id: string;
+            /**
+             * Start Time
+             * Format: date-time
+             */
+            start_time: string;
+            /**
+             * End Time
+             * Format: date-time
+             */
+            end_time: string;
+            /** Traces */
+            traces: components["schemas"]["SessionTraceData"][];
+        };
+        /** SessionTraceData */
+        SessionTraceData: {
+            /** Id */
+            id: string;
+            /** Trace Id */
+            trace_id: string;
+            /**
+             * Start Time
+             * Format: date-time
+             */
+            start_time: string;
+            /**
+             * End Time
+             * Format: date-time
+             */
+            end_time: string;
+        };
         /** Span */
         Span: {
             /**
@@ -5618,6 +5701,113 @@ export interface operations {
             };
         };
     };
+    getSession: {
+        parameters: {
+            query?: never;
+            header?: never;
+            path: {
+                /** @description The session identifier: either a GlobalID or user-provided session_id string. */
+                session_identifier: string;
+            };
+            cookie?: never;
+        };
+        requestBody?: never;
+        responses: {
+            /** @description Successful Response */
+            200: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": components["schemas"]["GetSessionResponseBody"];
+                };
+            };
+            /** @description Forbidden */
+            403: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "text/plain": string;
+                };
+            };
+            /** @description Not Found */
+            404: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "text/plain": string;
+                };
+            };
+            /** @description Unprocessable Entity */
+            422: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "text/plain": string;
+                };
+            };
+        };
+    };
+    listProjectSessions: {
+        parameters: {
+            query?: {
+                /** @description Cursor for pagination (session ID) */
+                cursor?: string | null;
+                /** @description The max number of sessions to return at a time. */
+                limit?: number;
+                /** @description Sort order by ID: 'asc' (ascending) or 'desc' (descending). */
+                order?: "asc" | "desc";
+            };
+            header?: never;
+            path: {
+                /** @description The project identifier: either project ID or project name. */
+                project_identifier: string;
+            };
+            cookie?: never;
+        };
+        requestBody?: never;
+        responses: {
+            /** @description Successful Response */
+            200: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": components["schemas"]["GetSessionsResponseBody"];
+                };
+            };
+            /** @description Forbidden */
+            403: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "text/plain": string;
+                };
+            };
+            /** @description Not Found */
+            404: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "text/plain": string;
+                };
+            };
+            /** @description Unprocessable Entity */
+            422: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "text/plain": string;
+                };
+            };
+        };
+    };
     annotateSessions: {
         parameters: {
             query?: {

package/src/schemas/jsonLiteralSchema.ts

@@ -24,6 +24,6 @@ export const jsonLiteralSchema: z.ZodType<JSONLiteral> = z.lazy(() =>
   z.union([
     literalSchema,
     z.array(jsonLiteralSchema),
-    z.record(jsonLiteralSchema),
+    z.record(z.string(), jsonLiteralSchema),
   ])
 );

package/src/schemas/jsonSchema.ts

@@ -1,7 +1,7 @@
 import z from "zod";
 
 const jsonSchemaPropertiesSchema = z
-  .object({
+  .looseObject({
     type: z
       .enum([
         "string",
@@ -19,29 +19,22 @@ const jsonSchemaPropertiesSchema = z
       .describe("A description of the parameter"),
     enum: z.array(z.string()).optional().describe("The allowed values"),
   })
-  .passthrough()
   .describe("A map of parameter names to their definitions");
 
-export const jsonSchemaZodSchema = z
-  .object({
-    type: z.literal("object"),
-    properties: z.record(
-      z.union([
-        jsonSchemaPropertiesSchema,
-        z
-          .object({ anyOf: z.array(jsonSchemaPropertiesSchema) })
-          .describe("A list of possible parameter names to their definitions"),
-      ])
-    ),
-    required: z
-      .array(z.string())
-      .optional()
-      .describe("The required parameters"),
-    additionalProperties: z
-      .boolean()
-      .optional()
-      .describe(
-        "Whether or not additional properties are allowed in the schema"
-      ),
-  })
-  .passthrough();
+export const jsonSchemaZodSchema = z.looseObject({
+  type: z.literal("object"),
+  properties: z.record(
+    z.string(),
+    z.union([
+      jsonSchemaPropertiesSchema,
+      z
+        .object({ anyOf: z.array(jsonSchemaPropertiesSchema) })
+        .describe("A list of possible parameter names to their definitions"),
+    ])
+  ),
+  required: z.array(z.string()).optional().describe("The required parameters"),
+  additionalProperties: z
+    .boolean()
+    .optional()
+    .describe("Whether or not additional properties are allowed in the schema"),
+});

package/src/schemas/llm/anthropic/messageSchemas.ts

@@ -1,5 +1,4 @@
 import z from "zod";
-import zodToJsonSchema from "zod-to-json-schema";
 
 import { anthropicMessagePartSchema } from "./messagePartSchemas";
 
@@ -15,23 +14,15 @@ export type AnthropicMessageRole = z.infer<typeof anthropicMessageRoleSchema>;
 /**
  * TODO: rewrite as discriminated union
  */
-export const anthropicMessageSchema = z
-  .object({
-    role: anthropicMessageRoleSchema,
-    content: z.union([z.string(), z.array(anthropicMessagePartSchema)]),
-  })
-  .passthrough();
+export const anthropicMessageSchema = z.looseObject({
+  role: anthropicMessageRoleSchema,
+  content: z.union([z.string(), z.array(anthropicMessagePartSchema)]),
+});
 
 export type AnthropicMessage = z.infer<typeof anthropicMessageSchema>;
 
 export const anthropicMessagesSchema = z.array(anthropicMessageSchema);
 
-// Type assertion needed due to TypeScript's deep type instantiation limits with complex recursive schemas
-// This is safe because zodToJsonSchema works correctly at runtime regardless of TypeScript's type analysis
-export const anthropicMessagesJSONSchema = zodToJsonSchema(
-  // eslint-disable-next-line @typescript-eslint/no-explicit-any
-  anthropicMessagesSchema as any, // TODO: use zod4 toJSONSchema instead
-  {
-    removeAdditionalStrategy: "passthrough",
-  }
+export const anthropicMessagesJSONSchema = z.toJSONSchema(
+  anthropicMessagesSchema
 );

package/src/schemas/llm/converters.ts

@@ -179,6 +179,11 @@ export const toOpenAIMessage = (message: unknown): OpenAIMessage | null => {
 /**
  * Convert from OpenAI message format to any other format
  */
+// Casts to ReturnType below are unavoidable: TypeScript cannot narrow a generic
+// type parameter (TargetProviderSDK) through switch/case control flow, so the
+// indexed access type remains unresolved in each branch. The casts are sound
+// because each branch accesses the correct provider's converter and
+// assertUnreachable ensures exhaustive coverage.
 export const fromOpenAIMessage = <
   TargetProviderSDK extends NonNullable<PromptSDKFormat>,
 >({
@@ -190,20 +195,27 @@ export const fromOpenAIMessage = <
 }): z.infer<
   (typeof SDKProviderConverterMap)[TargetProviderSDK]["messages"]["fromOpenAI"]
 > => {
+  type ReturnType = z.infer<
+    (typeof SDKProviderConverterMap)[TargetProviderSDK]["messages"]["fromOpenAI"]
+  >;
   switch (targetProvider) {
     case "AZURE_OPENAI":
     case "OPENAI":
-      return SDKProviderConverterMap.OPENAI.messages.fromOpenAI.parse(message);
+      return SDKProviderConverterMap.OPENAI.messages.fromOpenAI.parse(
+        message
+      ) as ReturnType;
     case "ANTHROPIC":
       return SDKProviderConverterMap.ANTHROPIC.messages.fromOpenAI.parse(
         message
-      );
+      ) as ReturnType;
     case "PHOENIX":
-      return SDKProviderConverterMap.PHOENIX.messages.fromOpenAI.parse(message);
+      return SDKProviderConverterMap.PHOENIX.messages.fromOpenAI.parse(
+        message
+      ) as ReturnType;
     case "VERCEL_AI":
       return SDKProviderConverterMap.VERCEL_AI.messages.fromOpenAI.parse(
         message
-      );
+      ) as ReturnType;
     default:
       return assertUnreachable(targetProvider);
   }
@@ -248,6 +260,7 @@ export const toOpenAIToolCall = (
  * @param params.targetProvider the provider to convert the tool call to
  * @returns the tool call in the target provider format
  */
+// See comment on fromOpenAIMessage for why `as ReturnType` casts are needed.
 export const fromOpenAIToolCall = <
   TargetProviderSDK extends NonNullable<PromptSDKFormat>,
 >({
@@ -259,24 +272,27 @@ export const fromOpenAIToolCall = <
 }): z.infer<
   (typeof SDKProviderConverterMap)[TargetProviderSDK]["toolCalls"]["fromOpenAI"]
 > => {
+  type ReturnType = z.infer<
+    (typeof SDKProviderConverterMap)[TargetProviderSDK]["toolCalls"]["fromOpenAI"]
+  >;
   switch (targetProvider) {
     case "AZURE_OPENAI":
     case "OPENAI":
       return SDKProviderConverterMap.OPENAI.toolCalls.fromOpenAI.parse(
         toolCall
-      );
+      ) as ReturnType;
     case "ANTHROPIC":
       return SDKProviderConverterMap.ANTHROPIC.toolCalls.fromOpenAI.parse(
         toolCall
-      );
+      ) as ReturnType;
     case "PHOENIX":
       return SDKProviderConverterMap.PHOENIX.toolCalls.fromOpenAI.parse(
         toolCall
-      );
+      ) as ReturnType;
     case "VERCEL_AI":
       return SDKProviderConverterMap.VERCEL_AI.toolCalls.fromOpenAI.parse(
         toolCall
-      );
+      ) as ReturnType;
     default:
       assertUnreachable(targetProvider);
   }
@@ -323,6 +339,7 @@ export const toOpenAIToolChoice = (
  * @param params.targetProvider the provider to convert the tool choice to
  * @returns the tool choice in the target provider format
  */
+// See comment on fromOpenAIMessage for why `as ReturnType` casts are needed.
 export const fromOpenAIToolChoice = <
   TargetProviderSDK extends NonNullable<PromptSDKFormat>,
 >({
@@ -334,24 +351,27 @@ export const fromOpenAIToolChoice = <
 }): z.infer<
   (typeof SDKProviderConverterMap)[TargetProviderSDK]["toolChoices"]["fromOpenAI"]
 > => {
+  type ReturnType = z.infer<
+    (typeof SDKProviderConverterMap)[TargetProviderSDK]["toolChoices"]["fromOpenAI"]
+  >;
   switch (targetProvider) {
     case "AZURE_OPENAI":
     case "OPENAI":
       return SDKProviderConverterMap.OPENAI.toolChoices.fromOpenAI.parse(
         toolChoice
-      );
+      ) as ReturnType;
     case "ANTHROPIC":
       return SDKProviderConverterMap.ANTHROPIC.toolChoices.fromOpenAI.parse(
         toolChoice
-      );
+      ) as ReturnType;
     case "PHOENIX":
       return SDKProviderConverterMap.PHOENIX.toolChoices.fromOpenAI.parse(
         toolChoice
-      );
+      ) as ReturnType;
     case "VERCEL_AI":
       return SDKProviderConverterMap.VERCEL_AI.toolChoices.fromOpenAI.parse(
         toolChoice
-      );
+      ) as ReturnType;
     default:
       assertUnreachable(targetProvider);
   }
@@ -393,6 +413,7 @@ export const toOpenAIToolDefinition = (
 /**
  * Convert from OpenAI tool call format to any other format
  */
+// See comment on fromOpenAIMessage for why `as ReturnType` casts are needed.
 export const fromOpenAIToolDefinition = <
   TargetProviderSDK extends NonNullable<PromptSDKFormat>,
 >({
@@ -404,24 +425,27 @@ export const fromOpenAIToolDefinition = <
 }): z.infer<
   (typeof SDKProviderConverterMap)[TargetProviderSDK]["toolDefinitions"]["fromOpenAI"]
 > => {
+  type ReturnType = z.infer<
+    (typeof SDKProviderConverterMap)[TargetProviderSDK]["toolDefinitions"]["fromOpenAI"]
+  >;
   switch (targetProvider) {
     case "AZURE_OPENAI":
     case "OPENAI":
       return SDKProviderConverterMap.OPENAI.toolDefinitions.fromOpenAI.parse(
         toolDefinition
-      );
+      ) as ReturnType;
     case "ANTHROPIC":
       return SDKProviderConverterMap.ANTHROPIC.toolDefinitions.fromOpenAI.parse(
         toolDefinition
-      );
+      ) as ReturnType;
     case "PHOENIX":
       return SDKProviderConverterMap.PHOENIX.toolDefinitions.fromOpenAI.parse(
         toolDefinition
-      );
+      ) as ReturnType;
     case "VERCEL_AI":
       return SDKProviderConverterMap.VERCEL_AI.toolDefinitions.fromOpenAI.parse(
         toolDefinition
-      );
+      ) as ReturnType;
     default:
       assertUnreachable(targetProvider);
   }

package/src/schemas/llm/openai/messageSchemas.ts

@@ -24,53 +24,41 @@ export const openAIMessageRoleSchema = z.enum([
 export type OpenAIMessageRole = z.infer<typeof openAIMessageRoleSchema>;
 
 export const openAIMessageSchema = z.discriminatedUnion("role", [
-  z
-    .object({
-      role: z.literal("assistant"),
-      content: z.union([openaiChatPartTextSchema.array(), z.string()]),
-      name: z.string().optional(),
-      tool_call_id: z.string().optional(),
-      tool_calls: z.array(openAIToolCallSchema).optional(),
-    })
-    .passthrough(),
-  z
-    .object({
-      role: z.literal("tool"),
-      content: z.union([openaiChatPartTextSchema.array(), z.string()]),
-      tool_call_id: z.string(),
-    })
-    .passthrough(),
-  z
-    .object({
-      role: z.literal("function"),
-      content: z.string().nullable(),
-      name: z.string(),
-    })
-    .passthrough(),
-  z
-    .object({
-      role: z.literal("user"),
-      content: z.union([
-        z.array(z.union([openaiChatPartTextSchema, openaiChatPartImageSchema])),
-        z.string(),
-      ]),
-      name: z.string().optional(),
-    })
-    .passthrough(),
-  z
-    .object({
-      role: z.literal("system"),
-      content: z.union([openaiChatPartTextSchema.array(), z.string()]),
-      name: z.string().optional(),
-    })
-    .passthrough(),
-  z
-    .object({
-      role: z.literal("developer"),
-      content: z.union([openaiChatPartTextSchema.array(), z.string()]),
-      name: z.string().optional(),
-    })
-    .passthrough(),
+  z.looseObject({
+    role: z.literal("assistant"),
+    content: z.union([openaiChatPartTextSchema.array(), z.string()]),
+    name: z.string().optional(),
+    tool_call_id: z.string().optional(),
+    tool_calls: z.array(openAIToolCallSchema).optional(),
+  }),
+  z.looseObject({
+    role: z.literal("tool"),
+    content: z.union([openaiChatPartTextSchema.array(), z.string()]),
+    tool_call_id: z.string(),
+  }),
+  z.looseObject({
+    role: z.literal("function"),
+    content: z.string().nullable(),
+    name: z.string(),
+  }),
+  z.looseObject({
+    role: z.literal("user"),
+    content: z.union([
+      z.array(z.union([openaiChatPartTextSchema, openaiChatPartImageSchema])),
+      z.string(),
+    ]),
+    name: z.string().optional(),
+  }),
+  z.looseObject({
+    role: z.literal("system"),
+    content: z.union([openaiChatPartTextSchema.array(), z.string()]),
+    name: z.string().optional(),
+  }),
+  z.looseObject({
+    role: z.literal("developer"),
+    content: z.union([openaiChatPartTextSchema.array(), z.string()]),
+    name: z.string().optional(),
+  }),
 ]);
 
 export type OpenAIMessage = z.infer<typeof openAIMessageSchema>;

package/src/schemas/llm/openai/toolCallSchemas.ts

@@ -14,12 +14,11 @@ export const openAIToolCallSchema = z.object({
     .transform(() => "function" as const),
   id: z.string().describe("The ID of the tool call"),
   function: z
-    .object({
+    .looseObject({
       name: z.string().describe("The name of the function"),
       arguments: z.string().describe("The arguments for the function"),
     })
-    .describe("The function that is being called")
-    .passthrough(),
+    .describe("The function that is being called"),
 });
 
 /**

package/src/schemas/llm/openai/toolSchemas.ts

@@ -10,31 +10,28 @@ import { jsonSchemaZodSchema } from "../../jsonSchema";
  * allow for extra keys when the zod schema is used for parsing. This is to allow more flexibility for users
  * to define their own tools according
  */
-export const openAIToolDefinitionSchema = z
-  .object({
-    type: z.literal("function").describe("The type of the tool"),
-    function: z
-      .object({
-        name: z.string().describe("The name of the function"),
-        description: z
-          .string()
-          .optional()
-          .describe("A description of the function"),
-        parameters: jsonSchemaZodSchema
-          .extend({
-            strict: z
-              .boolean()
-              .optional()
-              .describe(
-                "Whether or not the arguments should exactly match the function definition, only supported for OpenAI models"
-              ),
-          })
-          .describe("The parameters that the function accepts"),
-      })
-      .passthrough()
-      .describe("The function definition"),
-  })
-  .passthrough();
+export const openAIToolDefinitionSchema = z.looseObject({
+  type: z.literal("function").describe("The type of the tool"),
+  function: z
+    .looseObject({
+      name: z.string().describe("The name of the function"),
+      description: z
+        .string()
+        .optional()
+        .describe("A description of the function"),
+      parameters: jsonSchemaZodSchema
+        .extend({
+          strict: z
+            .boolean()
+            .optional()
+            .describe(
+              "Whether or not the arguments should exactly match the function definition, only supported for OpenAI models"
+            ),
+        })
+        .describe("The parameters that the function accepts"),
+    })
+    .describe("The function definition"),
+});
 
 /**
  * The type of an OpenAI tool definition

package/src/schemas/llm/phoenixPrompt/messagePartSchemas.ts

@@ -41,7 +41,7 @@ export const toolResultPartSchema = schemaMatches<
       z.number(),
       z.boolean(),
       z.null(),
-      z.record(z.unknown()),
+      z.record(z.string(), z.unknown()),
       z.array(z.unknown()),
     ]),
   })