@arizeai/phoenix-client 5.8.2 → 6.0.0

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

@@ -1,30 +1,27 @@
+import invariant from "tiny-invariant";
+
 import { assertUnreachable } from "../../../utils/assertUnreachable";
 import { safelyStringifyJSON } from "../../../utils/safelyStringifyJSON";
-import {
+import type {
   OpenAIChatPart,
   OpenAIChatPartImage,
   OpenAIChatPartText,
 } from "../openai/messagePartSchemas";
-import {
-  OpenAIMessage,
-  openAIMessageRoleSchema,
-} from "../openai/messageSchemas";
-import { OpenAIToolCall } from "../openai/toolCallSchemas";
-import { OpenaiToolChoice } from "../openai/toolChoiceSchemas";
-import { OpenAIToolDefinition } from "../openai/toolSchemas";
-
-import {
+import type { OpenAIMessage } from "../openai/messageSchemas";
+import { openAIMessageRoleSchema } from "../openai/messageSchemas";
+import type { OpenAIToolCall } from "../openai/toolCallSchemas";
+import type { OpenaiToolChoice } from "../openai/toolChoiceSchemas";
+import type { OpenAIToolDefinition } from "../openai/toolSchemas";
+import type {
   AnthropicMessagePart,
-  anthropicMessagePartSchema,
   AnthropicToolUseBlock,
 } from "./messagePartSchemas";
+import { anthropicMessagePartSchema } from "./messagePartSchemas";
 import { anthropicMessageSchema } from "./messageSchemas";
 import { anthropicToolCallSchema } from "./toolCallSchemas";
 import { anthropicToolChoiceSchema } from "./toolChoiceSchemas";
 import { anthropicToolDefinitionSchema } from "./toolSchemas";
 
-import invariant from "tiny-invariant";
-
 /*
  * Conversion Functions
  *

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

@@ -1,7 +1,7 @@
-import { anthropicToolCallSchema } from "./toolCallSchemas";
-
 import z from "zod";
 
+import { anthropicToolCallSchema } from "./toolCallSchemas";
+
 /*
  *
  * Anthropic Message Part Schemas

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

@@ -1,7 +1,6 @@
-import { anthropicMessagePartSchema } from "./messagePartSchemas";
-
 import z from "zod";
-import zodToJsonSchema from "zod-to-json-schema";
+
+import { anthropicMessagePartSchema } from "./messagePartSchemas";
 
 /**
  *
@@ -15,20 +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);
 
-export const anthropicMessagesJSONSchema = zodToJsonSchema(
-  anthropicMessagesSchema,
-  {
-    removeAdditionalStrategy: "passthrough",
-  }
+export const anthropicMessagesJSONSchema = z.toJSONSchema(
+  anthropicMessagesSchema
 );

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

@@ -1,7 +1,7 @@
-import { jsonLiteralSchema } from "../../jsonLiteralSchema";
-
 import z from "zod";
 
+import { jsonLiteralSchema } from "../../jsonLiteralSchema";
+
 /**
  * The schema for an Anthropic tool call, this is what a message that calls a tool looks like
  */

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

@@ -1,7 +1,7 @@
-import { jsonSchemaZodSchema } from "../../jsonSchema";
-
 import z from "zod";
 
+import { jsonSchemaZodSchema } from "../../jsonSchema";
+
 /**
  * The zod schema for an anthropic tool definition
  */

package/src/schemas/llm/constants.ts

@@ -1,5 +1,6 @@
-import { PromptProviderSDKs } from "../../types/prompts";
+import { z } from "zod";
 
+import type { PromptProviderSDKs } from "../../types/prompts";
 import {
   anthropicMessagePartToOpenAI,
   anthropicMessageToOpenAI,
@@ -32,13 +33,11 @@ import {
   phoenixToolChoiceToOpenAI,
   phoenixToolDefinitionToOpenAI,
 } from "./phoenixPrompt/converters";
+import { makeSDKConverters } from "./utils";
 import {
   vercelAIChatPartSchema,
   vercelAIChatPartToolCallSchema,
 } from "./vercel/messagePartSchemas";
-import { makeSDKConverters } from "./utils";
-
-import { z } from "zod";
 
 export const SDKProviderIdMap: Record<PromptProviderSDKs, string> = {
   OPENAI: "openai",

package/src/schemas/llm/converters.ts

@@ -1,15 +1,17 @@
+import invariant from "tiny-invariant";
+import type z from "zod";
+
 import { assertUnreachable } from "../../utils/assertUnreachable";
 import { safelyParseJSON } from "../../utils/safelyParseJSON";
-import { JSONLiteral } from "../jsonLiteralSchema";
-
-import { OpenAIChatPart } from "./openai/messagePartSchemas";
-import { OpenAIMessage } from "./openai/messageSchemas";
-import { OpenAIToolCall } from "./openai/toolCallSchemas";
-import { OpenaiToolChoice } from "./openai/toolChoiceSchemas";
-import { OpenAIToolDefinition } from "./openai/toolSchemas";
+import type { JSONLiteral } from "../jsonLiteralSchema";
 import { SDKProviderConverterMap } from "./constants";
+import type { OpenAIChatPart } from "./openai/messagePartSchemas";
+import type { OpenAIMessage } from "./openai/messageSchemas";
+import type { OpenAIToolCall } from "./openai/toolCallSchemas";
+import type { OpenaiToolChoice } from "./openai/toolChoiceSchemas";
+import type { OpenAIToolDefinition } from "./openai/toolSchemas";
 import { toolCallHeuristicSchema } from "./schemas";
-import { LLMMessagePart, PromptSDKFormat } from "./types";
+import type { LLMMessagePart, PromptSDKFormat } from "./types";
 import {
   detectMessagePartProvider,
   detectMessageProvider,
@@ -18,9 +20,6 @@ import {
   detectToolDefinitionProvider,
 } from "./utils";
 
-import invariant from "tiny-invariant";
-import z from "zod";
-
 export const safelyConvertMessageToProvider = <
   TargetProviderSDK extends NonNullable<PromptSDKFormat>,
 >({
@@ -180,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>,
 >({
@@ -191,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);
   }
@@ -249,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>,
 >({
@@ -260,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);
   }
@@ -324,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>,
 >({
@@ -335,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);
   }
@@ -394,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>,
 >({
@@ -405,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/converters.ts

@@ -1,37 +1,38 @@
+import invariant from "tiny-invariant";
+
 import { assertUnreachable } from "../../../utils/assertUnreachable";
 import { isObject } from "../../../utils/isObject";
-import {
+import type {
   AnthropicImageBlock,
   AnthropicMessagePart,
   AnthropicTextBlock,
   AnthropicToolUseBlock,
 } from "../anthropic/messagePartSchemas";
-import { AnthropicMessage } from "../anthropic/messageSchemas";
-import { AnthropicToolCall } from "../anthropic/toolCallSchemas";
-import { AnthropicToolChoice } from "../anthropic/toolChoiceSchemas";
-import { AnthropicToolDefinition } from "../anthropic/toolSchemas";
-import {
-  makeTextPart,
-  makeToolResultPart,
+import type { AnthropicMessage } from "../anthropic/messageSchemas";
+import type { AnthropicToolCall } from "../anthropic/toolCallSchemas";
+import type { AnthropicToolChoice } from "../anthropic/toolChoiceSchemas";
+import type { AnthropicToolDefinition } from "../anthropic/toolSchemas";
+import type {
   PhoenixContentPart,
   ToolCallPart,
 } from "../phoenixPrompt/messagePartSchemas";
 import {
+  makeTextPart,
+  makeToolResultPart,
+} from "../phoenixPrompt/messagePartSchemas";
+import type {
   PhoenixMessage,
   PhoenixMessageRole,
 } from "../phoenixPrompt/messageSchemas";
-import { VercelAIMessage } from "../vercel/messageSchemas";
-import { VercelAIToolChoice } from "../vercel/toolChoiceSchemas";
-import { VercelAIToolDefinition } from "../vercel/toolSchemas";
-
+import type { VercelAIMessage } from "../vercel/messageSchemas";
+import type { VercelAIToolChoice } from "../vercel/toolChoiceSchemas";
+import type { VercelAIToolDefinition } from "../vercel/toolSchemas";
 import { openaiChatPartSchema } from "./messagePartSchemas";
 import { openAIMessageSchema } from "./messageSchemas";
 import { openAIToolCallSchema } from "./toolCallSchemas";
 import { openAIToolChoiceSchema } from "./toolChoiceSchemas";
 import { openAIToolDefinitionSchema } from "./toolSchemas";
 
-import invariant from "tiny-invariant";
-
 export const openAIChatPartToAnthropic = openaiChatPartSchema.transform(
   (openai) => {
     const type = openai.type;

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

@@ -1,11 +1,11 @@
+import z from "zod";
+
 import {
   openaiChatPartImageSchema,
   openaiChatPartTextSchema,
 } from "./messagePartSchemas";
 import { openAIToolCallSchema } from "./toolCallSchemas";
 
-import z from "zod";
-
 /*
  *
  * OpenAI Message Schemas
@@ -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/responseFormatSchema.ts

@@ -1,7 +1,7 @@
-import { jsonSchemaZodSchema } from "../../jsonSchema";
-
 import z from "zod";
 
+import { jsonSchemaZodSchema } from "../../jsonSchema";
+
 /*
  *
  * Reponse format zod schemas

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

@@ -1,7 +1,7 @@
-import { jsonSchemaZodSchema } from "../../jsonSchema";
-
 import z from "zod";
 
+import { jsonSchemaZodSchema } from "../../jsonSchema";
+
 /**
  * The schema for an OpenAI tool definition
  * @see https://platform.openai.com/docs/guides/structured-outputs/supported-schemas
@@ -10,31 +10,28 @@ import z from "zod";
  * 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/converters.ts

@@ -1,18 +1,16 @@
 import { assertUnreachable } from "../../../utils/assertUnreachable";
 import { safelyStringifyJSON } from "../../../utils/safelyStringifyJSON";
 import { jsonSchemaZodSchema } from "../../jsonSchema";
-import { OpenAIChatPartText } from "../openai/messagePartSchemas";
-import { OpenAIMessage } from "../openai/messageSchemas";
-import { OpenAIResponseFormat } from "../openai/responseFormatSchema";
-import { OpenAIToolCall } from "../openai/toolCallSchemas";
-import { OpenaiToolChoice } from "../openai/toolChoiceSchemas";
-import { OpenAIToolDefinition } from "../openai/toolSchemas";
-
+import type { OpenAIChatPartText } from "../openai/messagePartSchemas";
+import type { OpenAIMessage } from "../openai/messageSchemas";
+import type { OpenAIResponseFormat } from "../openai/responseFormatSchema";
+import type { OpenAIToolCall } from "../openai/toolCallSchemas";
+import type { OpenaiToolChoice } from "../openai/toolChoiceSchemas";
+import type { OpenAIToolDefinition } from "../openai/toolSchemas";
+import type { ToolCallPart, ToolResultPart } from "./messagePartSchemas";
 import {
   asToolResultPart,
   phoenixContentPartSchema,
-  ToolCallPart,
-  ToolResultPart,
 } from "./messagePartSchemas";
 import { phoenixMessageSchema } from "./messageSchemas";
 import { phoenixResponseFormatSchema } from "./responseFormatSchema";

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

@@ -1,8 +1,8 @@
+import z from "zod";
+
 import type { PromptChatMessagePart } from "../../../types/prompts";
 import { schemaMatches } from "../../../utils/schemaMatches";
 
-import z from "zod";
-
 export const textPartSchema = schemaMatches<
   Extract<PromptChatMessagePart, { type: "text" }>
 >()(
@@ -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()),
     ]),
   })

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

@@ -1,10 +1,9 @@
+import z from "zod";
+
 import type { PromptChatMessage } from "../../../types/prompts";
 import { schemaMatches } from "../../../utils/schemaMatches";
-
 import { phoenixContentPartSchema } from "./messagePartSchemas";
 
-import z from "zod";
-
 /**
  *
  * Prompt Message Schemas

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

@@ -1,8 +1,8 @@
-import { PromptResponseFormat } from "../../../types/prompts";
-import { schemaMatches } from "../../../utils/schemaMatches";
-
 import z from "zod";
 
+import type { PromptResponseFormat } from "../../../types/prompts";
+import { schemaMatches } from "../../../utils/schemaMatches";
+
 /**
  * Phoenix response format schema
  */
@@ -13,7 +13,7 @@ export const phoenixResponseFormatSchema =
       json_schema: z.object({
         name: z.string(),
         description: z.string().optional(),
-        schema: z.record(z.unknown()).optional(),
+        schema: z.record(z.string(), z.unknown()).optional(),
         strict: z.boolean().optional(),
       }),
     })