@arizeai/phoenix-client 6.9.1 → 6.9.2

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@arizeai/phoenix-client",
-  "version": "6.9.1",
+  "version": "6.9.2",
   "description": "A client for the Phoenix API",
   "keywords": [
     "arize",
@@ -76,7 +76,7 @@
     "@arizeai/openinference-semantic-conventions": "^2.1.7",
     "@arizeai/openinference-vercel": "^2.7.0",
     "async": "^3.2.6",
-    "openapi-fetch": "^0.12.5",
+    "openapi-fetch": "^0.17.0",
     "tiny-invariant": "^1.3.3",
     "zod": "^4.0.14",
     "@arizeai/phoenix-config": "0.1.4",

package/src/__generated__/api/v1.ts

@@ -74,7 +74,33 @@ export interface paths {
         get: operations["listSpanAnnotationsBySpanIds"];
         put?: never;
         post?: never;
-        delete?: never;
+        /**
+         * Delete span annotations in a project that match the supplied filter.
+         * @description Hard-delete span annotations within the named project that match the
+         *     supplied filter.
+         *
+         *     - The request must either supply both `start_time` AND `end_time`
+         *       to bound the delete to a `[start_time, end_time)` time window,
+         *       OR set `delete_all=true` to acknowledge an unbounded sweep. A request
+         *       that satisfies neither is rejected with 422.
+         *     - `name`, `identifier`, and `annotator_kind` are optional narrowing
+         *       filters; on their own they do NOT authorize the request — they only
+         *       narrow within an already-authorized request (bounded time range or
+         *       `delete_all=true`).
+         *     - All supplied filters are combined with AND. `name` and `identifier`,
+         *       when present, must be non-empty.
+         *     - `start_time` is inclusive (`>=`); `end_time` is exclusive
+         *       (`<`). When both are supplied, `start_time` must be strictly earlier
+         *       than `end_time` (else 422). A half-bounded range (only one of
+         *       the two) does NOT satisfy the gate and is rejected unless
+         *       `delete_all=true` is also set. Naive datetimes are interpreted as UTC.
+         *     - The endpoint is idempotent: a request that matches no rows still
+         *       returns 204.
+         *     - When authentication is enabled, non-admin callers can only delete rows
+         *       they own (`user_id == current_user.id`); admins delete all matching
+         *       rows.
+         */
+        delete: operations["deleteSpanAnnotations"];
         options?: never;
         head?: never;
         patch?: never;
@@ -94,7 +120,33 @@ export interface paths {
         get: operations["listTraceAnnotationsByTraceIds"];
         put?: never;
         post?: never;
-        delete?: never;
+        /**
+         * Delete trace annotations in a project that match the supplied filter.
+         * @description Hard-delete trace annotations within the named project that match the
+         *     supplied filter.
+         *
+         *     - The request must either supply both `start_time` AND `end_time`
+         *       to bound the delete to a `[start_time, end_time)` time window,
+         *       OR set `delete_all=true` to acknowledge an unbounded sweep. A request
+         *       that satisfies neither is rejected with 422.
+         *     - `name`, `identifier`, and `annotator_kind` are optional narrowing
+         *       filters; on their own they do NOT authorize the request — they only
+         *       narrow within an already-authorized request (bounded time range or
+         *       `delete_all=true`).
+         *     - All supplied filters are combined with AND. `name` and `identifier`,
+         *       when present, must be non-empty.
+         *     - `start_time` is inclusive (`>=`); `end_time` is exclusive
+         *       (`<`). When both are supplied, `start_time` must be strictly earlier
+         *       than `end_time` (else 422). A half-bounded range (only one of
+         *       the two) does NOT satisfy the gate and is rejected unless
+         *       `delete_all=true` is also set. Naive datetimes are interpreted as UTC.
+         *     - The endpoint is idempotent: a request that matches no rows still
+         *       returns 204.
+         *     - When authentication is enabled, non-admin callers can only delete rows
+         *       they own (`user_id == current_user.id`); admins delete all matching
+         *       rows.
+         */
+        delete: operations["deleteTraceAnnotations"];
         options?: never;
         head?: never;
         patch?: never;
@@ -114,7 +166,33 @@ export interface paths {
         get: operations["listSessionAnnotationsBySessionIds"];
         put?: never;
         post?: never;
-        delete?: never;
+        /**
+         * Delete session annotations in a project that match the supplied filter.
+         * @description Hard-delete session annotations within the named project that match the
+         *     supplied filter.
+         *
+         *     - The request must either supply both `start_time` AND `end_time`
+         *       to bound the delete to a `[start_time, end_time)` time window,
+         *       OR set `delete_all=true` to acknowledge an unbounded sweep. A request
+         *       that satisfies neither is rejected with 422.
+         *     - `name`, `identifier`, and `annotator_kind` are optional narrowing
+         *       filters; on their own they do NOT authorize the request — they only
+         *       narrow within an already-authorized request (bounded time range or
+         *       `delete_all=true`).
+         *     - All supplied filters are combined with AND. `name` and `identifier`,
+         *       when present, must be non-empty.
+         *     - `start_time` is inclusive (`>=`); `end_time` is exclusive
+         *       (`<`). When both are supplied, `start_time` must be strictly earlier
+         *       than `end_time` (else 422). A half-bounded range (only one of
+         *       the two) does NOT satisfy the gate and is rejected unless
+         *       `delete_all=true` is also set. Naive datetimes are interpreted as UTC.
+         *     - The endpoint is idempotent: a request that matches no rows still
+         *       returns 204.
+         *     - When authentication is enabled, non-admin callers can only delete rows
+         *       they own (`user_id == current_user.id`); admins delete all matching
+         *       rows.
+         */
+        delete: operations["deleteSessionAnnotations"];
         options?: never;
         head?: never;
         patch?: never;
@@ -2882,6 +2960,18 @@ export interface components {
             /** Strict */
             strict?: boolean;
         };
+        /** PromptToolRaw */
+        PromptToolRaw: {
+            /**
+             * @description discriminator enum property added by openapi-typescript
+             * @enum {string}
+             */
+            type: "raw";
+            /** Raw */
+            raw: {
+                [key: string]: unknown;
+            };
+        };
         /** PromptTools */
         PromptTools: {
             /**
@@ -2890,7 +2980,7 @@ export interface components {
              */
             type: "tools";
             /** Tools */
-            tools: components["schemas"]["PromptToolFunction"][];
+            tools: (components["schemas"]["PromptToolFunction"] | components["schemas"]["PromptToolRaw"])[];
             /** Tool Choice */
             tool_choice?: components["schemas"]["PromptToolChoiceNone"] | components["schemas"]["PromptToolChoiceZeroOrMore"] | components["schemas"]["PromptToolChoiceOneOrMore"] | components["schemas"]["PromptToolChoiceSpecificFunctionTool"];
             /** Disable Parallel Tool Calls */
@@ -3114,6 +3204,24 @@ export interface components {
             end_time: string;
             /** Traces */
             traces: components["schemas"]["SessionTraceData"][];
+            /**
+             * Token Count Prompt
+             * @description Cumulative prompt token count across all spans in the session.
+             * @default 0
+             */
+            token_count_prompt?: number;
+            /**
+             * Token Count Completion
+             * @description Cumulative completion token count across all spans in the session.
+             * @default 0
+             */
+            token_count_completion?: number;
+            /**
+             * Token Count Total
+             * @description Cumulative total token count across all spans in the session (prompt + completion).
+             * @default 0
+             */
+            token_count_total?: number;
         };
         /** SessionNoteData */
         SessionNoteData: {
@@ -3588,6 +3696,24 @@ export interface components {
              * Format: date-time
              */
             end_time: string;
+            /**
+             * Token Count Prompt
+             * @description Cumulative prompt token count across all spans in the trace.
+             * @default 0
+             */
+            token_count_prompt?: number;
+            /**
+             * Token Count Completion
+             * @description Cumulative completion token count across all spans in the trace.
+             * @default 0
+             */
+            token_count_completion?: number;
+            /**
+             * Token Count Total
+             * @description Cumulative total token count across all spans in the trace (prompt + completion).
+             * @default 0
+             */
+            token_count_total?: number;
             /** Spans */
             spans?: components["schemas"]["TraceSpanData"][] | null;
         };
@@ -4037,6 +4163,67 @@ export interface operations {
             };
         };
     };
+    deleteSpanAnnotations: {
+        parameters: {
+            query?: {
+                /** @description Optional annotation name. When provided, must be non-empty and narrows the delete to annotations of that name. */
+                name?: string | null;
+                /** @description Optional annotation identifier. When provided, must be non-empty and narrows the delete to annotations with that identifier. */
+                identifier?: string | null;
+                /** @description Optional annotator kind. When provided, narrows the delete to annotations produced by this annotator kind. */
+                annotator_kind?: ("LLM" | "CODE" | "HUMAN") | null;
+                /** @description Optional inclusive lower bound on `created_at` (>=). Naive datetimes are interpreted as UTC. */
+                start_time?: string | null;
+                /** @description Optional exclusive upper bound on `created_at` (<). Naive datetimes are interpreted as UTC. */
+                end_time?: string | null;
+                /** @description Opt-in flag that authorizes the request without a bounded `[start_time, end_time)` time window. When `false` (default) or absent, the request must supply both `start_time` AND `end_time` to bound the delete. When `true`, the time-range bound is waived and any other filters (`name`, `identifier`, `annotator_kind`) still narrow the delete within the project — e.g. `delete_all=true&name=X` deletes all annotations named X regardless of time. */
+                delete_all?: boolean;
+            };
+            header?: never;
+            path: {
+                /** @description The project identifier: either project ID or project name. If using a project name as the identifier, it cannot contain slash (/), question mark (?), or pound sign (#) characters. */
+                project_identifier: string;
+            };
+            cookie?: never;
+        };
+        requestBody?: never;
+        responses: {
+            /** @description Successful Response */
+            204: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content?: never;
+            };
+            /** @description Forbidden */
+            403: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "text/plain": string;
+                };
+            };
+            /** @description Project not found */
+            404: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "text/plain": string;
+                };
+            };
+            /** @description Invalid parameters */
+            422: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "text/plain": string;
+                };
+            };
+        };
+    };
     listTraceAnnotationsByTraceIds: {
         parameters: {
             query?: {
@@ -4100,6 +4287,67 @@ export interface operations {
             };
         };
     };
+    deleteTraceAnnotations: {
+        parameters: {
+            query?: {
+                /** @description Optional annotation name. When provided, must be non-empty and narrows the delete to annotations of that name. */
+                name?: string | null;
+                /** @description Optional annotation identifier. When provided, must be non-empty and narrows the delete to annotations with that identifier. */
+                identifier?: string | null;
+                /** @description Optional annotator kind. When provided, narrows the delete to annotations produced by this annotator kind. */
+                annotator_kind?: ("LLM" | "CODE" | "HUMAN") | null;
+                /** @description Optional inclusive lower bound on `created_at` (>=). Naive datetimes are interpreted as UTC. */
+                start_time?: string | null;
+                /** @description Optional exclusive upper bound on `created_at` (<). Naive datetimes are interpreted as UTC. */
+                end_time?: string | null;
+                /** @description Opt-in flag that authorizes the request without a bounded `[start_time, end_time)` time window. When `false` (default) or absent, the request must supply both `start_time` AND `end_time` to bound the delete. When `true`, the time-range bound is waived and any other filters (`name`, `identifier`, `annotator_kind`) still narrow the delete within the project — e.g. `delete_all=true&name=X` deletes all annotations named X regardless of time. */
+                delete_all?: boolean;
+            };
+            header?: never;
+            path: {
+                /** @description The project identifier: either project ID or project name. If using a project name as the identifier, it cannot contain slash (/), question mark (?), or pound sign (#) characters. */
+                project_identifier: string;
+            };
+            cookie?: never;
+        };
+        requestBody?: never;
+        responses: {
+            /** @description Successful Response */
+            204: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content?: never;
+            };
+            /** @description Forbidden */
+            403: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "text/plain": string;
+                };
+            };
+            /** @description Project not found */
+            404: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "text/plain": string;
+                };
+            };
+            /** @description Invalid parameters */
+            422: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "text/plain": string;
+                };
+            };
+        };
+    };
     listSessionAnnotationsBySessionIds: {
         parameters: {
             query?: {
@@ -4163,6 +4411,67 @@ export interface operations {
             };
         };
     };
+    deleteSessionAnnotations: {
+        parameters: {
+            query?: {
+                /** @description Optional annotation name. When provided, must be non-empty and narrows the delete to annotations of that name. */
+                name?: string | null;
+                /** @description Optional annotation identifier. When provided, must be non-empty and narrows the delete to annotations with that identifier. */
+                identifier?: string | null;
+                /** @description Optional annotator kind. When provided, narrows the delete to annotations produced by this annotator kind. */
+                annotator_kind?: ("LLM" | "CODE" | "HUMAN") | null;
+                /** @description Optional inclusive lower bound on `created_at` (>=). Naive datetimes are interpreted as UTC. */
+                start_time?: string | null;
+                /** @description Optional exclusive upper bound on `created_at` (<). Naive datetimes are interpreted as UTC. */
+                end_time?: string | null;
+                /** @description Opt-in flag that authorizes the request without a bounded `[start_time, end_time)` time window. When `false` (default) or absent, the request must supply both `start_time` AND `end_time` to bound the delete. When `true`, the time-range bound is waived and any other filters (`name`, `identifier`, `annotator_kind`) still narrow the delete within the project — e.g. `delete_all=true&name=X` deletes all annotations named X regardless of time. */
+                delete_all?: boolean;
+            };
+            header?: never;
+            path: {
+                /** @description The project identifier: either project ID or project name. If using a project name as the identifier, it cannot contain slash (/), question mark (?), or pound sign (#) characters. */
+                project_identifier: string;
+            };
+            cookie?: never;
+        };
+        requestBody?: never;
+        responses: {
+            /** @description Successful Response */
+            204: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content?: never;
+            };
+            /** @description Forbidden */
+            403: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "text/plain": string;
+                };
+            };
+            /** @description Project not found */
+            404: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "text/plain": string;
+                };
+            };
+            /** @description Invalid parameters */
+            422: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "text/plain": string;
+                };
+            };
+        };
+    };
     listDatasets: {
         parameters: {
             query?: {

package/src/prompts/sdks/toAI.ts

@@ -7,9 +7,27 @@ import {
   safelyConvertToolDefinitionToProvider,
 } from "../../schemas/llm/converters";
 import { findToolDefinitionName } from "../../schemas/llm/utils";
+import type { PromptToolRaw } from "../../types/prompts";
+import { isPromptToolRaw } from "../../types/prompts";
 import { formatPromptMessages } from "../../utils/formatPromptMessages";
 import type { Variables, toSDKParamsBase } from "./types";
 
+/**
+ * Best-effort name for a vendor-passthrough (raw) tool. Vercel AI SDK keys its
+ * `tools` record by tool name, so we need a stable string identifier even when
+ * the raw payload doesn't carry a conventional `name` field — fall back to
+ * `type` (e.g. "web_search") which the Responses-style SDKs use as the key.
+ */
+const getRawToolName = (tool: PromptToolRaw): string | null => {
+  if (typeof tool.raw.name === "string") {
+    return tool.raw.name;
+  }
+  if (typeof tool.raw.type === "string") {
+    return tool.raw.type;
+  }
+  return null;
+};
+
 export type PartialAIParams = {
   messages: ModelMessage[];
   /**
@@ -67,23 +85,27 @@ export const toAI = <V extends Variables>({
       return vercelAIMessage;
     });
 
+    const toolsList = prompt.tools?.tools ?? [];
     let tools: ToolSet | undefined;
-    if (prompt.tools?.tools && prompt.tools.tools.length > 0) {
+    if (toolsList.length > 0) {
       const toolsRecord: Record<string, unknown> = {};
-      for (const tool of prompt.tools.tools) {
-        const name = findToolDefinitionName(tool);
+      for (const tool of toolsList) {
+        const name = isPromptToolRaw(tool)
+          ? getRawToolName(tool)
+          : findToolDefinitionName(tool);
         invariant(name, "Tool definition name is not valid");
-        const converted = safelyConvertToolDefinitionToProvider({
-          toolDefinition: tool,
-          targetProvider: "VERCEL_AI",
-        });
+        const converted = isPromptToolRaw(tool)
+          ? tool.raw
+          : safelyConvertToolDefinitionToProvider({
+              toolDefinition: tool,
+              targetProvider: "VERCEL_AI",
+            });
         invariant(converted, "Tool definition is not valid");
         toolsRecord[name] = converted;
       }
-      tools =
-        Object.keys(toolsRecord).length > 0
-          ? (toolsRecord as ToolSet)
-          : undefined;
+      if (Object.keys(toolsRecord).length > 0) {
+        tools = toolsRecord as ToolSet;
+      }
     }
 
     let toolChoice: PartialAIParams["toolChoice"];

package/src/prompts/sdks/toAnthropic.ts

@@ -7,6 +7,7 @@ import {
   safelyConvertToolChoiceToProvider,
   safelyConvertToolDefinitionToProvider,
 } from "../../schemas/llm/converters";
+import { isPromptToolRaw } from "../../types/prompts";
 import { formatPromptMessages } from "../../utils/formatPromptMessages";
 import type { toSDKParamsBase, Variables } from "./types";
 
@@ -62,22 +63,32 @@ export const toAnthropic = <V extends Variables = Variables>({
       return anthropicMessage;
     });
 
-    let tools = prompt.tools?.tools.map((tool) => {
-      const anthropicToolDefinition = safelyConvertToolDefinitionToProvider({
-        toolDefinition: tool,
-        targetProvider: "ANTHROPIC",
-      });
-      invariant(anthropicToolDefinition, "Tool definition is not valid");
-      return anthropicToolDefinition;
-    });
-    tools = (tools?.length ?? 0) > 0 ? tools : undefined;
+    const toolsList = prompt.tools?.tools ?? [];
+    // Cast: raw tools are `Record<string, unknown>` straight from the prompt
+    // store. We trust the upstream caller to have stored a shape Anthropic's
+    // SDK accepts; no validation here.
+    const tools =
+      toolsList.length === 0
+        ? undefined
+        : (toolsList.map((tool) => {
+            if (isPromptToolRaw(tool)) {
+              return tool.raw;
+            }
+            const anthropicToolDefinition =
+              safelyConvertToolDefinitionToProvider({
+                toolDefinition: tool,
+                targetProvider: "ANTHROPIC",
+              });
+            invariant(anthropicToolDefinition, "Tool definition is not valid");
+            return anthropicToolDefinition;
+          }) as MessageCreateParams["tools"]);
 
-    let tool_choice: AnthropicToolChoice | undefined =
-      safelyConvertToolChoiceToProvider({
-        toolChoice: prompt?.tools?.tool_choice,
-        targetProvider: "ANTHROPIC",
-      }) || undefined;
-    tool_choice = tools?.length ? tool_choice : undefined;
+    const tool_choice: AnthropicToolChoice | undefined = tools
+      ? (safelyConvertToolChoiceToProvider({
+          toolChoice: prompt?.tools?.tool_choice,
+          targetProvider: "ANTHROPIC",
+        }) ?? undefined)
+      : undefined;
 
     // combine base and computed params
     const completionParams = {

package/src/prompts/sdks/toOpenAI.ts

@@ -12,6 +12,7 @@ import {
 } from "../../schemas/llm/converters";
 import type { OpenaiToolChoice } from "../../schemas/llm/openai/toolChoiceSchemas";
 import { phoenixResponseFormatToOpenAI } from "../../schemas/llm/phoenixPrompt/converters";
+import { isPromptToolRaw } from "../../types/prompts";
 import { formatPromptMessages } from "../../utils/formatPromptMessages";
 import type { toSDKParamsBase, Variables } from "./types";
 
@@ -74,22 +75,31 @@ export const toOpenAI = <V extends Variables = Variables>({
       return openAIMessage;
     });
 
-    let tools = prompt.tools?.tools.map((tool) => {
-      const openAIToolDefinition = safelyConvertToolDefinitionToProvider({
-        toolDefinition: tool,
-        targetProvider: "OPENAI",
-      });
-      invariant(openAIToolDefinition, "Tool definition is not valid");
-      return openAIToolDefinition;
-    });
-    tools = (tools?.length ?? 0) > 0 ? tools : undefined;
+    const toolsList = prompt.tools?.tools ?? [];
+    // Cast: raw tools are `Record<string, unknown>` straight from the prompt
+    // store. We trust the upstream caller to have stored a shape OpenAI's
+    // SDK accepts; no validation here.
+    const tools =
+      toolsList.length === 0
+        ? undefined
+        : (toolsList.map((tool) => {
+            if (isPromptToolRaw(tool)) {
+              return tool.raw;
+            }
+            const openAIToolDefinition = safelyConvertToolDefinitionToProvider({
+              toolDefinition: tool,
+              targetProvider: "OPENAI",
+            });
+            invariant(openAIToolDefinition, "Tool definition is not valid");
+            return openAIToolDefinition;
+          }) as unknown as ChatCompletionCreateParams["tools"]);
 
-    let tool_choice: OpenaiToolChoice | undefined =
-      safelyConvertToolChoiceToProvider({
-        toolChoice: prompt?.tools?.tool_choice,
-        targetProvider: "OPENAI",
-      }) || undefined;
-    tool_choice = tools?.length ? tool_choice : undefined;
+    const tool_choice: OpenaiToolChoice | undefined = tools
+      ? (safelyConvertToolChoiceToProvider({
+          toolChoice: prompt?.tools?.tool_choice,
+          targetProvider: "OPENAI",
+        }) ?? undefined)
+      : undefined;
 
     const response_format = prompt.response_format
       ? phoenixResponseFormatToOpenAI.parse(prompt.response_format)

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

@@ -16,7 +16,7 @@ import { phoenixMessageSchema } from "./messageSchemas";
 import { phoenixResponseFormatSchema } from "./responseFormatSchema";
 import { phoenixToolCallSchema } from "./toolCallSchemas";
 import { phoenixToolChoiceSchema } from "./toolChoiceSchemas";
-import { phoenixToolDefinitionSchema } from "./toolSchemas";
+import { phoenixToolFunctionDefinitionSchema } from "./toolSchemas";
 
 /*
  * Conversion Functions
@@ -150,7 +150,7 @@ export const phoenixToolCallToOpenAI = phoenixToolCallSchema.transform(
 );
 
 export const phoenixToolDefinitionToOpenAI =
-  phoenixToolDefinitionSchema.transform(
+  phoenixToolFunctionDefinitionSchema.transform(
     (phoenix): OpenAIToolDefinition => ({
       type: "function",
       function: {

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

@@ -1,21 +1,24 @@
 import z from "zod";
 
-import type { PromptTool } from "../../../types/prompts";
+import type { PromptToolFunction } from "../../../types/prompts";
 import { schemaMatches } from "../../../utils/schemaMatches";
 
 /**
  * The Phoenix tool definition schema
  */
-export const phoenixToolDefinitionSchema = schemaMatches<PromptTool>()(
-  z.object({
-    type: z.literal("function"),
-    function: z.object({
-      name: z.string(),
-      description: z.string().optional(),
-      parameters: z.record(z.string(), z.unknown()).optional(),
-      strict: z.boolean().optional(),
-    }),
-  })
-);
+export const phoenixToolFunctionDefinitionSchema =
+  schemaMatches<PromptToolFunction>()(
+    z.object({
+      type: z.literal("function"),
+      function: z.object({
+        name: z.string(),
+        description: z.string().optional(),
+        parameters: z.record(z.string(), z.unknown()).optional(),
+        strict: z.boolean().optional(),
+      }),
+    })
+  );
 
-export type PhoenixToolDefinition = z.infer<typeof phoenixToolDefinitionSchema>;
+export type PhoenixToolDefinition = z.infer<
+  typeof phoenixToolFunctionDefinitionSchema
+>;

package/src/schemas/llm/schemas.ts

@@ -11,7 +11,7 @@ import { openAIToolDefinitionSchema } from "./openai/toolSchemas";
 import { phoenixMessageSchema } from "./phoenixPrompt/messageSchemas";
 import { phoenixToolCallSchema } from "./phoenixPrompt/toolCallSchemas";
 import { phoenixToolChoiceSchema } from "./phoenixPrompt/toolChoiceSchemas";
-import { phoenixToolDefinitionSchema } from "./phoenixPrompt/toolSchemas";
+import { phoenixToolFunctionDefinitionSchema } from "./phoenixPrompt/toolSchemas";
 import { vercelAIChatPartToolCallSchema } from "./vercel/messagePartSchemas";
 import { vercelAIMessageSchema } from "./vercel/messageSchemas";
 import { vercelAIToolChoiceSchema } from "./vercel/toolChoiceSchemas";
@@ -87,7 +87,7 @@ export type LlmProviderToolChoice = z.infer<typeof llmProviderToolChoiceSchema>;
 export const llmProviderToolDefinitionSchema = z.union([
   openAIToolDefinitionSchema,
   anthropicToolDefinitionSchema,
-  phoenixToolDefinitionSchema,
+  phoenixToolFunctionDefinitionSchema,
 ]);
 
 export type LlmProviderToolDefinition = z.infer<