feat: convert tool call schemas between providers

app/src/pages/playground/ChatMessageToolCallsEditor.tsx

@@ -3,15 +3,14 @@ import { JSONSchema7 } from "json-schema";
 
 import { JSONEditor } from "@phoenix/components/code";
 import { usePlaygroundContext } from "@phoenix/contexts/PlaygroundContext";
-import {
-  openAIToolCallsJSONSchema,
-  openAIToolCallsSchema,
-} from "@phoenix/schemas";
+import { toolCallSchemas } from "@phoenix/schemas";
 import { ChatMessage } from "@phoenix/store";
 import { safelyParseJSON } from "@phoenix/utils/jsonUtils";
 
 import { PlaygroundInstanceProps } from "./types";
 
+const { openAIToolCallsSchema, openAIToolCallsJSONSchema } = toolCallSchemas;
+
 /**
  * Editor for message tool calls
  */

app/src/pages/playground/PlaygroundOutput.tsx

@@ -9,7 +9,7 @@ import { useNotifyError } from "@phoenix/contexts";
 import { useCredentialsContext } from "@phoenix/contexts/CredentialsContext";
 import { usePlaygroundContext } from "@phoenix/contexts/PlaygroundContext";
 import { useChatMessageStyles } from "@phoenix/hooks/useChatMessageStyles";
-import { OpenAIToolCall } from "@phoenix/schemas";
+import { OpenAIToolCall } from "@phoenix/schemas/toolCallSchemas";
 import { ChatMessage, generateMessageId } from "@phoenix/store";
 import { assertUnreachable } from "@phoenix/typeUtils";
 

app/src/pages/playground/PlaygroundTool.tsx

@@ -8,7 +8,10 @@ import { JSONEditor } from "@phoenix/components/code";
 import { LazyEditorWrapper } from "@phoenix/components/code/LazyEditorWrapper";
 import { SpanKindIcon } from "@phoenix/components/trace";
 import { usePlaygroundContext } from "@phoenix/contexts/PlaygroundContext";
-import { openAIToolJSONSchema, openAIToolSchema } from "@phoenix/schemas";
+import {
+  openAIToolDefinitionJSONSchema,
+  openAIToolDefinitionSchema,
+} from "@phoenix/schemas";
 import { OpenAITool } from "@phoenix/store";
 import { safelyParseJSON } from "@phoenix/utils/jsonUtils";
 
@@ -45,7 +48,7 @@ export function PlaygroundTool({
       // there is no "deepPassthrough" to allow for extra keys
       // at all levels of the schema, so we just use the json parsed value here,
       // knowing that it is valid with potentially extra keys
-      const { success } = openAIToolSchema.safeParse(definition);
+      const { success } = openAIToolDefinitionSchema.safeParse(definition);
       if (!success) {
         return;
       }
@@ -106,7 +109,7 @@ export function PlaygroundTool({
         <JSONEditor
           value={toolDefinition}
           onChange={onChange}
-          jsonSchema={openAIToolJSONSchema as JSONSchema7}
+          jsonSchema={openAIToolDefinitionJSONSchema as JSONSchema7}
         />
       </LazyEditorWrapper>
     </Card>

app/src/pages/playground/schemas.ts

@@ -7,7 +7,8 @@ import {
   ToolAttributePostfixes,
 } from "@arizeai/openinference-semantic-conventions";
 
-import { openAIToolCallSchema, openAIToolSchema } from "@phoenix/schemas";
+import { openAIToolDefinitionSchema } from "@phoenix/schemas";
+import { openAIToolCallSchema } from "@phoenix/schemas/toolCallSchemas";
 import { ChatMessage } from "@phoenix/store";
 import { isObject, Mutable, schemaForType } from "@phoenix/typeUtils";
 import { safelyParseJSON } from "@phoenix/utils/jsonUtils";
@@ -220,7 +221,7 @@ export const toolJSONSchemaSchema = z
   })
   // TODO(parker / apowell) - adjust this transformation with anthropic tool support https://github.com/Arize-ai/phoenix/issues/5100
   .transform((o, ctx) => {
-    const { data, success } = openAIToolSchema.safeParse(o);
+    const { data, success } = openAIToolDefinitionSchema.safeParse(o);
 
     if (!success) {
       ctx.addIssue({

app/src/pages/playground/toolCallSchemas.ts

@@ -0,0 +1,144 @@
+import { z } from "zod";
+
+import { assertUnreachable } from "@phoenix/typeUtils";
+
+export const jsonSchema = z
+  .object({
+    type: z.string(),
+    // content changes based on the type
+    // see https://json-schema.org/understanding-json-schema/reference/type
+  })
+  .passthrough();
+
+/**
+ * --------------------------------
+ * Provider Schemas
+ * --------------------------------
+ */
+
+/**
+ * OpenAI tool call format
+ */
+export const openAIToolCallSchema = z.object({
+  id: z.string().nullish(),
+  type: z.literal("function"),
+  function: z.object({
+    name: z.string(),
+    description: z.string().nullish(),
+    parameters: jsonSchema,
+  }),
+});
+
+export type OpenAIToolCall = z.infer<typeof openAIToolCallSchema>;
+
+/**
+ * Anthropic tool call format
+ */
+export const anthropicToolCallSchema = z.object({
+  name: z.string(),
+  description: z.string(),
+  input_schema: jsonSchema,
+});
+
+export type AnthropicToolCall = z.infer<typeof anthropicToolCallSchema>;
+
+/**
+ * --------------------------------
+ * Conversion Schemas
+ * --------------------------------
+ */
+
+/**
+ * Parse incoming object as an Anthropic tool call and immediately convert to OpenAI format
+ */
+export const anthropicToOpenAI = anthropicToolCallSchema.transform(
+  (anthropic): OpenAIToolCall => ({
+    id: null, // generate?
+    type: "function",
+    function: {
+      name: anthropic.name,
+      description: anthropic.description,
+      parameters: anthropic.input_schema,
+    },
+  })
+);
+
+/**
+ * Parse incoming object as an OpenAI tool call and immediately convert to Anthropic format
+ */
+export const openAIToAnthropic = openAIToolCallSchema.transform(
+  (openai): AnthropicToolCall => ({
+    name: openai.function.name,
+    description: openai.function.description ?? openai.function.name,
+    input_schema: openai.function.parameters,
+  })
+);
+
+/**
+ * --------------------------------
+ * Conversion Helpers
+ * --------------------------------
+ */
+
+// Helper type for provider identification
+export const providerType = z.enum(["openai", "anthropic"]);
+export type ProviderType = z.infer<typeof providerType>;
+
+/**
+ * Union of all tool call formats
+ *
+ * This is useful for functions that need to accept any tool call format
+ */
+export const anyToolCallSchema = z.union([
+  openAIToolCallSchema,
+  anthropicToolCallSchema,
+]);
+
+export type AnyToolCall = z.infer<typeof anyToolCallSchema>;
+
+/**
+ * Convert from any tool call format to OpenAI format
+ */
+export const toOpenAIFormat = (
+  toolCall: AnyToolCall,
+  provider: ProviderType
+): OpenAIToolCall => {
+  switch (provider) {
+    case "openai":
+      return toolCall as OpenAIToolCall;
+    case "anthropic":
+      return anthropicToOpenAI.parse(toolCall as AnthropicToolCall);
+    default:
+      assertUnreachable(provider);
+  }
+};
+
+/**
+ * Convert from OpenAI tool call format to any other format
+ */
+export const fromOpenAIFormat = (
+  toolCall: OpenAIToolCall,
+  targetProvider: ProviderType
+): AnyToolCall => {
+  switch (targetProvider) {
+    case "openai":
+      return toolCall;
+    case "anthropic":
+      return openAIToAnthropic.parse(toolCall);
+    default:
+      assertUnreachable(targetProvider);
+  }
+};
+
+/**
+ * Detect the provider of a tool call object
+ */
+export const detectProvider = (toolCall: unknown): ProviderType => {
+  if (openAIToolCallSchema.safeParse(toolCall).success) {
+    return "openai";
+  }
+  if (anthropicToolCallSchema.safeParse(toolCall).success) {
+    return "anthropic";
+  }
+  throw new Error("Unknown tool call format");
+};

app/src/schemas/index.ts

@@ -1 +1,2 @@
 export * from "./toolSchemas";
+export * as toolCallSchemas from "./toolCallSchemas";