@arizeai/phoenix-client 6.9.1 → 6.9.3

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";
 
@@ -35,14 +36,47 @@ export const toOpenAI = <V extends Variables = Variables>({
 }: ToOpenAIParams<V>): ChatCompletionCreateParams | null => {
   try {
     let invocationParameters: Partial<ChatCompletionCreateParams>;
-    if (prompt.invocation_parameters.type === "openai") {
-      invocationParameters = prompt.invocation_parameters.openai;
-    } else {
-      // eslint-disable-next-line no-console
-      console.warn(
-        "Prompt is not an OpenAI prompt, falling back to default OpenAI invocation parameters"
-      );
-      invocationParameters = {};
+    switch (prompt.invocation_parameters.type) {
+      case "openai":
+        invocationParameters = prompt.invocation_parameters.openai;
+        break;
+      case "azure_openai":
+        invocationParameters = prompt.invocation_parameters.azure_openai;
+        break;
+      case "deepseek":
+        invocationParameters = prompt.invocation_parameters.deepseek;
+        break;
+      case "xai":
+        invocationParameters = prompt.invocation_parameters.xai;
+        break;
+      case "ollama":
+        invocationParameters = prompt.invocation_parameters.ollama;
+        break;
+      case "cerebras":
+        invocationParameters = prompt.invocation_parameters.cerebras;
+        break;
+      case "fireworks":
+        invocationParameters = prompt.invocation_parameters.fireworks;
+        break;
+      case "groq":
+        invocationParameters = prompt.invocation_parameters.groq;
+        break;
+      case "moonshot":
+        invocationParameters = prompt.invocation_parameters.moonshot;
+        break;
+      case "perplexity":
+        invocationParameters = prompt.invocation_parameters.perplexity;
+        break;
+      case "together":
+        invocationParameters = prompt.invocation_parameters.together;
+        break;
+      default:
+        // eslint-disable-next-line no-console
+        console.warn(
+          "Prompt is not an OpenAI-family prompt, falling back to default OpenAI invocation parameters"
+        );
+        invocationParameters = {};
+        break;
     }
     // parts of the prompt that can be directly converted to OpenAI params
     const baseCompletionParams = {
@@ -74,22 +108,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<

package/src/schemas/llm/utils.ts

@@ -15,7 +15,7 @@ import { phoenixContentPartSchema } from "./phoenixPrompt/messagePartSchemas";
 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 { llmProviderToolDefinitionSchema } from "./schemas";
 import type {
   LLMMessagePart,
@@ -206,7 +206,7 @@ export const detectToolDefinitionProvider = (
     };
   }
   const { success: phoenixSuccess, data: phoenixData } =
-    phoenixToolDefinitionSchema.safeParse(toolDefinition);
+    phoenixToolFunctionDefinitionSchema.safeParse(toolDefinition);
   if (phoenixSuccess) {
     return { provider: "PHOENIX", validatedToolDefinition: phoenixData };
   }

package/src/types/prompts.ts

@@ -161,11 +161,24 @@ export type PromptChatMessagePart =
   | components["schemas"]["ToolCallContentPart"]
   | components["schemas"]["ToolResultContentPart"];
 
+export type PromptToolFunction = components["schemas"]["PromptToolFunction"];
+export type PromptToolRaw = components["schemas"]["PromptToolRaw"];
+
 /**
  * The Phoenix prompt tool type from the API.
  */
 export type PromptTool = components["schemas"]["PromptTools"]["tools"][number];
 
+export function isPromptToolRaw(tool: PromptTool): tool is PromptToolRaw {
+  return tool.type === "raw";
+}
+
+export function isPromptToolFunction(
+  tool: PromptTool
+): tool is PromptToolFunction {
+  return tool.type === "function";
+}
+
 /**
  * The Phoenix prompt tool choice type from the API.
  */