@arizeai/phoenix-client
Version:
A client for the Phoenix API
332 lines • 15.3 kB
JavaScript
"use strict";
var __importDefault = (this && this.__importDefault) || function (mod) {
return (mod && mod.__esModule) ? mod : { "default": mod };
};
Object.defineProperty(exports, "__esModule", { value: true });
exports.fromOpenAIToolDefinition = exports.toOpenAIToolDefinition = exports.fromOpenAIToolChoice = exports.toOpenAIToolChoice = exports.fromOpenAIToolCall = exports.toOpenAIToolCall = exports.fromOpenAIMessage = exports.toOpenAIMessage = exports.toOpenAIChatPart = exports.safelyConvertToolChoiceToProvider = exports.safelyConvertToolDefinitionToProvider = exports.safelyConvertToolCallToProvider = exports.safelyConvertMessageToProvider = void 0;
exports.findToolCallId = findToolCallId;
exports.findToolCallName = findToolCallName;
exports.findToolCallArguments = findToolCallArguments;
const assertUnreachable_1 = require("../../utils/assertUnreachable");
const safelyParseJSON_1 = require("../../utils/safelyParseJSON");
const constants_1 = require("./constants");
const schemas_1 = require("./schemas");
const utils_1 = require("./utils");
const tiny_invariant_1 = __importDefault(require("tiny-invariant"));
const safelyConvertMessageToProvider = ({ message, targetProvider, }) => {
try {
// convert incoming message to OpenAI format
const openAIMessage = (0, exports.toOpenAIMessage)(message);
(0, tiny_invariant_1.default)(openAIMessage != null, `Could not convert message to ${targetProvider} format`);
// convert the OpenAI format to the target provider format
return (0, exports.fromOpenAIMessage)({ message: openAIMessage, targetProvider });
}
catch (_a) {
return null;
}
};
exports.safelyConvertMessageToProvider = safelyConvertMessageToProvider;
const safelyConvertToolCallToProvider = ({ toolCall, targetProvider, }) => {
try {
// convert incoming tool call to OpenAI format
const openAIToolCall = (0, exports.toOpenAIToolCall)(toolCall);
(0, tiny_invariant_1.default)(openAIToolCall != null, `Could not convert tool call to ${targetProvider} format`);
// convert the OpenAI format to the target provider format
return (0, exports.fromOpenAIToolCall)({
toolCall: openAIToolCall,
targetProvider,
});
}
catch (_a) {
return null;
}
};
exports.safelyConvertToolCallToProvider = safelyConvertToolCallToProvider;
const safelyConvertToolDefinitionToProvider = ({ toolDefinition, targetProvider, }) => {
try {
// convert incoming tool definition to OpenAI format
const openAIToolDefinition = (0, exports.toOpenAIToolDefinition)(toolDefinition);
(0, tiny_invariant_1.default)(openAIToolDefinition != null, `Could not convert tool definition to ${targetProvider} format`);
// convert the OpenAI format to the target provider format
return (0, exports.fromOpenAIToolDefinition)({
toolDefinition: openAIToolDefinition,
targetProvider,
});
}
catch (_a) {
return null;
}
};
exports.safelyConvertToolDefinitionToProvider = safelyConvertToolDefinitionToProvider;
const safelyConvertToolChoiceToProvider = ({ toolChoice, targetProvider, }) => {
try {
// convert incoming tool choice to OpenAI format
const openAIToolChoice = (0, exports.toOpenAIToolChoice)(toolChoice);
(0, tiny_invariant_1.default)(openAIToolChoice != null, `Could not convert tool choice to ${targetProvider} format`);
// convert the OpenAI format to the target provider format
return (0, exports.fromOpenAIToolChoice)({
toolChoice: openAIToolChoice,
targetProvider,
});
}
catch (_a) {
return null;
}
};
exports.safelyConvertToolChoiceToProvider = safelyConvertToolChoiceToProvider;
const toOpenAIChatPart = (part) => {
const { provider, validatedMessage } = (0, utils_1.detectMessagePartProvider)(part);
switch (provider) {
case "AZURE_OPENAI":
case "OPENAI":
return validatedMessage;
case "ANTHROPIC":
return constants_1.SDKProviderConverterMap.ANTHROPIC.messageParts.toOpenAI.parse(validatedMessage);
case "PHOENIX":
return constants_1.SDKProviderConverterMap.PHOENIX.messageParts.toOpenAI.parse(validatedMessage);
case "VERCEL_AI":
return constants_1.SDKProviderConverterMap.VERCEL_AI.messageParts.toOpenAI.parse(validatedMessage);
case null:
return null;
default:
return (0, assertUnreachable_1.assertUnreachable)(provider);
}
};
exports.toOpenAIChatPart = toOpenAIChatPart;
/**
* Convert from any message format to OpenAI format if possible
*/
const toOpenAIMessage = (message) => {
const { provider, validatedMessage } = (0, utils_1.detectMessageProvider)(message);
switch (provider) {
case "AZURE_OPENAI":
case "OPENAI":
return validatedMessage;
case "ANTHROPIC":
return constants_1.SDKProviderConverterMap.ANTHROPIC.messages.toOpenAI.parse(validatedMessage);
case "PHOENIX":
return constants_1.SDKProviderConverterMap.PHOENIX.messages.toOpenAI.parse(validatedMessage);
case "VERCEL_AI":
return constants_1.SDKProviderConverterMap.VERCEL_AI.messages.toOpenAI.parse(validatedMessage);
case null:
return null;
default:
return (0, assertUnreachable_1.assertUnreachable)(provider);
}
};
exports.toOpenAIMessage = toOpenAIMessage;
/**
* Convert from OpenAI message format to any other format
*/
const fromOpenAIMessage = ({ message, targetProvider, }) => {
switch (targetProvider) {
case "AZURE_OPENAI":
case "OPENAI":
return constants_1.SDKProviderConverterMap.OPENAI.messages.fromOpenAI.parse(message);
case "ANTHROPIC":
return constants_1.SDKProviderConverterMap.ANTHROPIC.messages.fromOpenAI.parse(message);
case "PHOENIX":
return constants_1.SDKProviderConverterMap.PHOENIX.messages.fromOpenAI.parse(message);
case "VERCEL_AI":
return constants_1.SDKProviderConverterMap.VERCEL_AI.messages.fromOpenAI.parse(message);
default:
return (0, assertUnreachable_1.assertUnreachable)(targetProvider);
}
};
exports.fromOpenAIMessage = fromOpenAIMessage;
/**
* Converts a tool call to the OpenAI format if possible
* @param maybeToolCall a tool call from an unknown LlmProvider
* @returns the tool call parsed to the OpenAI format
*/
const toOpenAIToolCall = (maybeToolCall) => {
const { provider, validatedToolCall } = (0, utils_1.detectToolCallProvider)(maybeToolCall);
switch (provider) {
case "AZURE_OPENAI":
case "OPENAI":
return validatedToolCall;
case "ANTHROPIC":
return constants_1.SDKProviderConverterMap.ANTHROPIC.toolCalls.toOpenAI.parse(validatedToolCall);
case "PHOENIX":
return constants_1.SDKProviderConverterMap.PHOENIX.toolCalls.toOpenAI.parse(validatedToolCall);
case "VERCEL_AI":
return constants_1.SDKProviderConverterMap.VERCEL_AI.toolCalls.toOpenAI.parse(validatedToolCall);
case null:
return null;
default:
return (0, assertUnreachable_1.assertUnreachable)(provider);
}
};
exports.toOpenAIToolCall = toOpenAIToolCall;
/**
* Converts a tool call to a target provider format
* @param params the parameters object
* @param params.toolCall the tool call to convert
* @param params.targetProvider the provider to convert the tool call to
* @returns the tool call in the target provider format
*/
const fromOpenAIToolCall = ({ toolCall, targetProvider, }) => {
switch (targetProvider) {
case "AZURE_OPENAI":
case "OPENAI":
return constants_1.SDKProviderConverterMap.OPENAI.toolCalls.fromOpenAI.parse(toolCall);
case "ANTHROPIC":
return constants_1.SDKProviderConverterMap.ANTHROPIC.toolCalls.fromOpenAI.parse(toolCall);
case "PHOENIX":
return constants_1.SDKProviderConverterMap.PHOENIX.toolCalls.fromOpenAI.parse(toolCall);
case "VERCEL_AI":
return constants_1.SDKProviderConverterMap.VERCEL_AI.toolCalls.fromOpenAI.parse(toolCall);
default:
(0, assertUnreachable_1.assertUnreachable)(targetProvider);
}
};
exports.fromOpenAIToolCall = fromOpenAIToolCall;
/**
* Converts a tool choice to the OpenAI format
* @param toolChoice a tool choice from an unknown LlmProvider
* @returns the tool choice parsed to the OpenAI format
*/
const toOpenAIToolChoice = (toolChoice) => {
const { provider, toolChoice: validatedToolChoice } = (0, utils_1.detectToolChoiceProvider)(toolChoice);
if (provider == null || validatedToolChoice == null) {
throw new Error("Could not detect provider of tool choice");
}
switch (provider) {
case "AZURE_OPENAI":
case "OPENAI":
return validatedToolChoice;
case "ANTHROPIC":
return constants_1.SDKProviderConverterMap.ANTHROPIC.toolChoices.toOpenAI.parse(validatedToolChoice);
case "PHOENIX":
return constants_1.SDKProviderConverterMap.PHOENIX.toolChoices.toOpenAI.parse(validatedToolChoice);
case "VERCEL_AI":
return constants_1.SDKProviderConverterMap.VERCEL_AI.toolChoices.toOpenAI.parse(validatedToolChoice);
default:
(0, assertUnreachable_1.assertUnreachable)(provider);
}
};
exports.toOpenAIToolChoice = toOpenAIToolChoice;
/**
* Converts a tool choice to a target provider format
* @param params the parameters object
* @param params.toolChoice the tool choice to convert
* @param params.targetProvider the provider to convert the tool choice to
* @returns the tool choice in the target provider format
*/
const fromOpenAIToolChoice = ({ toolChoice, targetProvider, }) => {
switch (targetProvider) {
case "AZURE_OPENAI":
case "OPENAI":
return constants_1.SDKProviderConverterMap.OPENAI.toolChoices.fromOpenAI.parse(toolChoice);
case "ANTHROPIC":
return constants_1.SDKProviderConverterMap.ANTHROPIC.toolChoices.fromOpenAI.parse(toolChoice);
case "PHOENIX":
return constants_1.SDKProviderConverterMap.PHOENIX.toolChoices.fromOpenAI.parse(toolChoice);
case "VERCEL_AI":
return constants_1.SDKProviderConverterMap.VERCEL_AI.toolChoices.fromOpenAI.parse(toolChoice);
default:
(0, assertUnreachable_1.assertUnreachable)(targetProvider);
}
};
exports.fromOpenAIToolChoice = fromOpenAIToolChoice;
/**
* Convert from any tool call format to OpenAI format if possible
*/
const toOpenAIToolDefinition = (toolDefinition) => {
const { provider, validatedToolDefinition } = (0, utils_1.detectToolDefinitionProvider)(toolDefinition);
switch (provider) {
case "AZURE_OPENAI":
case "OPENAI":
return constants_1.SDKProviderConverterMap.OPENAI.toolDefinitions.toOpenAI.parse(validatedToolDefinition);
case "ANTHROPIC":
return constants_1.SDKProviderConverterMap.ANTHROPIC.toolDefinitions.toOpenAI.parse(validatedToolDefinition);
case "PHOENIX":
return constants_1.SDKProviderConverterMap.PHOENIX.toolDefinitions.toOpenAI.parse(validatedToolDefinition);
case "VERCEL_AI":
return constants_1.SDKProviderConverterMap.VERCEL_AI.toolDefinitions.toOpenAI.parse(validatedToolDefinition);
case null:
return null;
default:
(0, assertUnreachable_1.assertUnreachable)(provider);
}
};
exports.toOpenAIToolDefinition = toOpenAIToolDefinition;
/**
* Convert from OpenAI tool call format to any other format
*/
const fromOpenAIToolDefinition = ({ toolDefinition, targetProvider, }) => {
switch (targetProvider) {
case "AZURE_OPENAI":
case "OPENAI":
return constants_1.SDKProviderConverterMap.OPENAI.toolDefinitions.fromOpenAI.parse(toolDefinition);
case "ANTHROPIC":
return constants_1.SDKProviderConverterMap.ANTHROPIC.toolDefinitions.fromOpenAI.parse(toolDefinition);
case "PHOENIX":
return constants_1.SDKProviderConverterMap.PHOENIX.toolDefinitions.fromOpenAI.parse(toolDefinition);
case "VERCEL_AI":
return constants_1.SDKProviderConverterMap.VERCEL_AI.toolDefinitions.fromOpenAI.parse(toolDefinition);
default:
(0, assertUnreachable_1.assertUnreachable)(targetProvider);
}
};
exports.fromOpenAIToolDefinition = fromOpenAIToolDefinition;
function findToolCallId(maybeToolCall) {
var _a, _b;
let subject = maybeToolCall;
if (typeof maybeToolCall === "string") {
const parsed = (0, safelyParseJSON_1.safelyParseJSON)(maybeToolCall);
subject = parsed.json;
}
const toolCall = (0, exports.toOpenAIToolCall)(subject);
if (toolCall) {
return toolCall.id;
}
// we don't have first class support for the incoming tool call
// try some heuristics to find the id
const heuristic = schemas_1.toolCallHeuristicSchema.safeParse(subject);
if (heuristic.success) {
return (_b = (_a = heuristic.data.id) !== null && _a !== void 0 ? _a : heuristic.data.name) !== null && _b !== void 0 ? _b : null;
}
return null;
}
function findToolCallName(maybeToolCall) {
var _a, _b, _c, _d;
let subject = maybeToolCall;
if (typeof maybeToolCall === "string") {
const parsed = (0, safelyParseJSON_1.safelyParseJSON)(maybeToolCall);
subject = parsed.json;
}
const toolCall = (0, exports.toOpenAIToolCall)(subject);
if (toolCall) {
return toolCall.function.name;
}
// we don't have first class support for the incoming tool call
// try some heuristics to find the name
const heuristic = schemas_1.toolCallHeuristicSchema.safeParse(subject);
if (heuristic.success) {
return ((_d = (_c = (_b = (_a = heuristic.data.function) === null || _a === void 0 ? void 0 : _a.name) !== null && _b !== void 0 ? _b : heuristic.data.name) !== null && _c !== void 0 ? _c :
// fallback to id if we don't have a name
heuristic.data.id) !== null && _d !== void 0 ? _d : null);
}
return null;
}
function findToolCallArguments(maybeToolCall) {
var _a, _b, _c;
let subject = maybeToolCall;
if (typeof maybeToolCall === "string") {
const parsed = (0, safelyParseJSON_1.safelyParseJSON)(maybeToolCall);
subject = parsed.json;
}
const toolCall = (0, exports.toOpenAIToolCall)(subject);
if (toolCall) {
return toolCall.function.arguments;
}
// we don't have first class support for the incoming tool call
// try some heuristics to find the arguments
const heuristic = schemas_1.toolCallHeuristicSchema.safeParse(subject);
if (heuristic.success) {
return ((_c = ((_a = heuristic.data.arguments) !== null && _a !== void 0 ? _a : (_b = heuristic.data.function) === null || _b === void 0 ? void 0 : _b.arguments)) !== null && _c !== void 0 ? _c : null);
}
return null;
}
//# sourceMappingURL=converters.js.map