@arizeai/phoenix-evals 0.5.1 → 0.6.1

package/src/__generated__/default_templates/HALLUCINATION_CLASSIFICATION_EVALUATOR_CONFIG.ts

@@ -0,0 +1,45 @@
+// This file is generated. Do not edit by hand.
+
+import type { ClassificationEvaluatorConfig } from "../types";
+
+export const HALLUCINATION_CLASSIFICATION_EVALUATOR_CONFIG: ClassificationEvaluatorConfig = {
+  name: "hallucination",
+  description: "A specialized evaluator for detecting hallucinations in grounded LLM responses.",
+  optimizationDirection: "MINIMIZE",
+  template: [
+    {
+      role: "user",
+      content: `
+In this task, you will be presented with a query, some context and a response. The response
+is generated to the question based on the context. The response may contain false
+information. You must use the context to determine if the response to the question
+contains false information, if the response is a hallucination of facts. Your objective is
+to determine whether the response text contains factual information and is not a
+hallucination. A 'hallucination' refers to a response that is not based on the context or
+assumes information that is not available in the context. Your response should be a single
+word: either 'factual' or 'hallucinated', and it should not include any other text or
+characters. 'hallucinated' indicates that the response provides factually inaccurate
+information to the query based on the context. 'factual' indicates that the response to
+the question is correct relative to the context, and does not contain made up
+information. Please read the query and context carefully before determining your
+response.
+
+[BEGIN DATA]
+************
+[Query]: {{input}}
+************
+[Context]: {{context}}
+************
+[Response]: {{output}}
+************
+[END DATA]
+
+Is the response above factual or hallucinated based on the query and context?
+`,
+    },
+  ],
+  choices: {
+  "hallucinated": 1,
+  "factual": 0
+},
+};

package/src/__generated__/default_templates/index.ts

@@ -0,0 +1,4 @@
+// This file is generated. Do not edit by hand.
+
+export { DOCUMENT_RELEVANCE_CLASSIFICATION_EVALUATOR_CONFIG } from "./DOCUMENT_RELEVANCE_CLASSIFICATION_EVALUATOR_CONFIG";
+export { HALLUCINATION_CLASSIFICATION_EVALUATOR_CONFIG } from "./HALLUCINATION_CLASSIFICATION_EVALUATOR_CONFIG";

package/src/__generated__/types.ts

@@ -0,0 +1,11 @@
+// This file is generated. Do not edit by hand.
+
+import type { PromptTemplate } from "../types/templating";
+
+export type ClassificationEvaluatorConfig = {
+  name: string;
+  description: string;
+  optimizationDirection: "MINIMIZE" | "MAXIMIZE";
+  template: PromptTemplate;
+  choices: Record<string, number>;
+};

package/src/core/EvaluatorBase.ts

@@ -0,0 +1,43 @@
+import {
+  CreateEvaluatorArgs,
+  EvaluationKind,
+  EvaluationResult,
+  EvaluatorInterface,
+  OptimizationDirection,
+  TelemetryConfig,
+} from "../types";
+import { ObjectMapping } from "../types/data";
+
+/**
+ * Base class for all evaluators
+ */
+export abstract class EvaluatorBase<RecordType extends Record<string, unknown>>
+  implements EvaluatorInterface<RecordType>
+{
+  readonly name: string;
+  readonly kind: EvaluationKind;
+  readonly optimizationDirection?: OptimizationDirection;
+  readonly inputMapping?: ObjectMapping<RecordType>;
+  readonly telemetry?: TelemetryConfig;
+  constructor({
+    name,
+    kind,
+    optimizationDirection,
+    inputMapping,
+    telemetry,
+  }: CreateEvaluatorArgs<RecordType>) {
+    this.name = name;
+    this.kind = kind;
+    this.optimizationDirection = optimizationDirection;
+    this.inputMapping = inputMapping;
+    this.telemetry = telemetry;
+  }
+  abstract evaluate(_example: RecordType): Promise<EvaluationResult>;
+
+  /**
+   * Binds the input mapping to the evaluator. It makes a a copy of the evaluator and returns it.
+   */
+  abstract bindInputMapping(
+    inputMapping: ObjectMapping<RecordType>
+  ): EvaluatorBase<RecordType>;
+}

package/src/index.ts

@@ -1,3 +1,4 @@
 export * from "./llm";
 export * from "./template";
 export * from "./types";
+export * from "./utils";

package/src/llm/ClassificationEvaluator.ts

@@ -1,14 +1,19 @@
 import { getTemplateVariables } from "../template";
 import {
+  ClassificationChoicesMap,
   CreateClassificationEvaluatorArgs,
   EvaluatorFn,
   PromptTemplate,
   WithPromptTemplate,
 } from "../types";
+import { ObjectMapping } from "../types/data";
+import { remapObject } from "../utils/objectMappingUtils";
 
 import { createClassifierFn } from "./createClassifierFn";
 import { LLMEvaluator } from "./LLMEvaluator";
 
+import { LanguageModel } from "ai";
+
 /**
  * An LLM evaluator that performs evaluation via classification
  */
@@ -18,14 +23,34 @@ export class ClassificationEvaluator<RecordType extends Record<string, unknown>>
 {
   readonly evaluatorFn: EvaluatorFn<RecordType>;
   readonly promptTemplate: PromptTemplate;
+  /**
+   * A dynamically computed set of prompt template variables
+   */
   private _promptTemplateVariables: string[] | undefined;
-  constructor(args: CreateClassificationEvaluatorArgs) {
+  /**
+   * The model to use for classification
+   */
+  readonly model: LanguageModel;
+  /**
+   * The choices to classify the example into
+   */
+  readonly choices: ClassificationChoicesMap;
+
+  constructor(args: CreateClassificationEvaluatorArgs<RecordType>) {
     super(args);
     this.promptTemplate = args.promptTemplate;
-    this.evaluatorFn = createClassifierFn<RecordType>(args);
+    this.model = args.model;
+    this.choices = args.choices;
+    this.evaluatorFn = createClassifierFn<RecordType>({
+      ...args,
+    });
   }
   evaluate = (example: RecordType) => {
-    return this.evaluatorFn(example);
+    return this.evaluatorFn(
+      this.inputMapping
+        ? remapObject<RecordType>(example, this.inputMapping)
+        : example
+    );
   };
   /**
    * List out the prompt template variables needed to perform evaluation
@@ -40,4 +65,15 @@ export class ClassificationEvaluator<RecordType extends Record<string, unknown>>
     // Give a copy of the variables
     return [...this._promptTemplateVariables];
   }
+  /**
+   * Binds the input mapping to the evaluator. It makes a a copy of the evaluator and returns it.
+   */
+  bindInputMapping(
+    inputMapping: ObjectMapping<RecordType>
+  ): ClassificationEvaluator<RecordType> {
+    return new ClassificationEvaluator({
+      ...this,
+      inputMapping,
+    });
+  }
 }

package/src/llm/LLMEvaluator.ts

@@ -1,22 +1,13 @@
-import {
-  CreateEvaluatorArgs,
-  EvaluationResult,
-  Evaluator,
-  OptimizationDirection,
-} from "../types";
+import { EvaluatorBase } from "../core/EvaluatorBase";
+import { CreateLLMEvaluatorArgs } from "../types";
 
 /**
  * Base class for llm evaluation metrics / scores
  */
-export abstract class LLMEvaluator<RecordType extends Record<string, unknown>>
-  implements Evaluator<RecordType>
-{
-  readonly name: string;
-  readonly kind = "LLM" as const;
-  readonly optimizationDirection?: OptimizationDirection;
-  constructor({ name, optimizationDirection }: CreateEvaluatorArgs) {
-    this.name = name;
-    this.optimizationDirection = optimizationDirection;
+export abstract class LLMEvaluator<
+  RecordType extends Record<string, unknown>,
+> extends EvaluatorBase<RecordType> {
+  constructor({ ...args }: CreateLLMEvaluatorArgs<RecordType>) {
+    super({ kind: "LLM", ...args });
   }
-  abstract evaluate(_example: RecordType): Promise<EvaluationResult>;
 }

package/src/llm/createClassificationEvaluator.ts

@@ -5,7 +5,7 @@ import { ClassificationEvaluator } from "./ClassificationEvaluator";
 export function createClassificationEvaluator<
   RecordType extends Record<string, unknown>,
 >(
-  args: CreateClassificationEvaluatorArgs
+  args: CreateClassificationEvaluatorArgs<RecordType>
 ): ClassificationEvaluator<RecordType> {
   return new ClassificationEvaluator<RecordType>(args);
 }

package/src/llm/createDocumentRelevanceEvaluator.ts

@@ -0,0 +1,79 @@
+import { DOCUMENT_RELEVANCE_CLASSIFICATION_EVALUATOR_CONFIG } from "../__generated__/default_templates";
+import { CreateClassificationEvaluatorArgs } from "../types/evals";
+
+import { ClassificationEvaluator } from "./ClassificationEvaluator";
+import { createClassificationEvaluator } from "./createClassificationEvaluator";
+
+export interface DocumentRelevanceEvaluatorArgs<
+  RecordType extends Record<
+    string,
+    unknown
+  > = DocumentRelevanceEvaluationRecord,
+> extends Omit<
+    CreateClassificationEvaluatorArgs<RecordType>,
+    "promptTemplate" | "choices" | "optimizationDirection" | "name"
+  > {
+  optimizationDirection?: CreateClassificationEvaluatorArgs<RecordType>["optimizationDirection"];
+  name?: CreateClassificationEvaluatorArgs<RecordType>["name"];
+  choices?: CreateClassificationEvaluatorArgs<RecordType>["choices"];
+  promptTemplate?: CreateClassificationEvaluatorArgs<RecordType>["promptTemplate"];
+}
+
+/**
+ * A record to be evaluated by the document relevance evaluator.
+ */
+export interface DocumentRelevanceEvaluationRecord {
+  input: string;
+  documentText: string;
+  [key: string]: unknown;
+}
+
+/**
+ * Creates a document relevance evaluator function.
+ *
+ * This function returns an evaluator that determines whether a given document text
+ * is relevant to a provided input question. The evaluator uses a classification model
+ * and a prompt template to make its determination.
+ *
+ * @param args - The arguments for creating the document relevance evaluator.
+ * @param args.model - The model to use for classification.
+ * @param args.choices - The possible classification choices (defaults to DOCUMENT_RELEVANCE_CHOICES).
+ * @param args.promptTemplate - The prompt template to use (defaults to DOCUMENT_RELEVANCE_TEMPLATE).
+ * @param args.telemetry - The telemetry to use for the evaluator.
+ *
+ * @returns An evaluator function that takes a {@link DocumentRelevanceExample} and returns a classification result
+ * indicating whether the document is relevant to the input question.
+ *
+ * @example
+ * ```ts
+ * const evaluator = createDocumentRelevanceEvaluator({ model: openai("gpt-4o-mini") });
+ * const result = await evaluator.evaluate({
+ *   input: "What is the capital of France?",
+ *   documentText: "Paris is the capital and most populous city of France.",
+ * });
+ * console.log(result.label); // "relevant" or "unrelated"
+ * ```
+ */
+export function createDocumentRelevanceEvaluator<
+  RecordType extends Record<
+    string,
+    unknown
+  > = DocumentRelevanceEvaluationRecord,
+>(
+  args: DocumentRelevanceEvaluatorArgs<RecordType>
+): ClassificationEvaluator<RecordType> {
+  const {
+    choices = DOCUMENT_RELEVANCE_CLASSIFICATION_EVALUATOR_CONFIG.choices,
+    promptTemplate = DOCUMENT_RELEVANCE_CLASSIFICATION_EVALUATOR_CONFIG.template,
+    optimizationDirection = DOCUMENT_RELEVANCE_CLASSIFICATION_EVALUATOR_CONFIG.optimizationDirection,
+    name = DOCUMENT_RELEVANCE_CLASSIFICATION_EVALUATOR_CONFIG.name,
+    ...rest
+  } = args;
+  return createClassificationEvaluator<RecordType>({
+    ...rest,
+    promptTemplate,
+    choices,
+    optimizationDirection,
+    name,
+  });
+}

package/src/llm/createHallucinationEvaluator.ts

@@ -1,21 +1,19 @@
-import {
-  HALLUCINATION_CHOICES,
-  HALLUCINATION_TEMPLATE,
-} from "../default_templates/HALLUCINATION_TEMPLATE";
+import { HALLUCINATION_CLASSIFICATION_EVALUATOR_CONFIG } from "../__generated__/default_templates";
 import { CreateClassificationEvaluatorArgs } from "../types/evals";
 
 import { ClassificationEvaluator } from "./ClassificationEvaluator";
 import { createClassificationEvaluator } from "./createClassificationEvaluator";
 
-export interface HallucinationEvaluatorArgs
-  extends Omit<
-    CreateClassificationEvaluatorArgs,
+export interface HallucinationEvaluatorArgs<
+  RecordType extends Record<string, unknown> = HallucinationEvaluationRecord,
+> extends Omit<
+    CreateClassificationEvaluatorArgs<RecordType>,
     "promptTemplate" | "choices" | "optimizationDirection" | "name"
   > {
-  optimizationDirection?: CreateClassificationEvaluatorArgs["optimizationDirection"];
-  name?: CreateClassificationEvaluatorArgs["name"];
-  choices?: CreateClassificationEvaluatorArgs["choices"];
-  promptTemplate?: CreateClassificationEvaluatorArgs["promptTemplate"];
+  optimizationDirection?: CreateClassificationEvaluatorArgs<RecordType>["optimizationDirection"];
+  name?: CreateClassificationEvaluatorArgs<RecordType>["name"];
+  choices?: CreateClassificationEvaluatorArgs<RecordType>["choices"];
+  promptTemplate?: CreateClassificationEvaluatorArgs<RecordType>["promptTemplate"];
 }
 
 /**
@@ -24,7 +22,6 @@ export interface HallucinationEvaluatorArgs
 export type HallucinationEvaluationRecord = {
   input: string;
   output: string;
-  reference?: string;
   context?: string;
 };
 /**
@@ -35,20 +32,21 @@ export type HallucinationEvaluationRecord = {
  */
 export function createHallucinationEvaluator<
   RecordType extends Record<string, unknown> = HallucinationEvaluationRecord,
->(args: HallucinationEvaluatorArgs): ClassificationEvaluator<RecordType> {
+>(
+  args: HallucinationEvaluatorArgs<RecordType>
+): ClassificationEvaluator<RecordType> {
   const {
-    choices = HALLUCINATION_CHOICES,
-    promptTemplate = HALLUCINATION_TEMPLATE,
-    optimizationDirection = "MINIMIZE",
-    name = "hallucination",
+    choices = HALLUCINATION_CLASSIFICATION_EVALUATOR_CONFIG.choices,
+    promptTemplate = HALLUCINATION_CLASSIFICATION_EVALUATOR_CONFIG.template,
+    optimizationDirection = HALLUCINATION_CLASSIFICATION_EVALUATOR_CONFIG.optimizationDirection,
+    name = HALLUCINATION_CLASSIFICATION_EVALUATOR_CONFIG.name,
     ...rest
   } = args;
   return createClassificationEvaluator<RecordType>({
-    ...args,
+    ...rest,
     promptTemplate,
     choices,
     optimizationDirection,
     name,
-    ...rest,
   });
 }

package/src/llm/index.ts

@@ -2,6 +2,6 @@ export * from "./generateClassification";
 export * from "./createClassifierFn";
 export * from "./createClassificationEvaluator";
 export * from "./createHallucinationEvaluator";
-export * from "./createDocumentRelevancyEvaluator";
+export * from "./createDocumentRelevanceEvaluator";
 export * from "./ClassificationEvaluator";
 export * from "./LLMEvaluator";

package/src/types/data.ts

@@ -0,0 +1,200 @@
+/**
+ * A value extractor that can retrieve data from an object using various methods.
+ *
+ * This type supports multiple ways to extract values from your data structure:
+ * - **String paths**: Simple property names, dot notation, or JSONPath expressions
+ * - **Function extractors**: Custom transformation functions
+ *
+ * @example
+ * **Simple property access:**
+ * ```typescript
+ * const getter: ValueGetter<{ name: string }> = "name";
+ * ```
+ *
+ * @example
+ * **Dot notation for nested properties:**
+ * ```typescript
+ * const getter: ValueGetter<{ user: { profile: { name: string } } }> = "user.profile.name";
+ * ```
+ *
+ * @example
+ * **Array element access:**
+ * ```typescript
+ * const getter: ValueGetter<{ items: string[] }> = "items[0]";
+ * ```
+ *
+ * @example
+ * **JSONPath expression:**
+ * ```typescript
+ * const getter: ValueGetter<{ items: Array<{ id: number }> }> = "$.items[*].id";
+ * ```
+ *
+ * @example
+ * **Function-based extraction:**
+ * ```typescript
+ * const getter: ValueGetter<{ firstName: string; lastName: string }> =
+ *   (data) => `${data.firstName} ${data.lastName}`;
+ * ```
+ *
+ * @example
+ * **Complex transformation:**
+ * ```typescript
+ * const getter: ValueGetter<{ scores: number[] }> =
+ *   (data) => data.scores.reduce((a, b) => a + b, 0) / data.scores.length;
+ * ```
+ *
+ * @typeParam DataType - The type of the data object to extract values from
+ */
+export type ValueGetter<DataType extends Record<string, unknown>> =
+  | string
+  // eslint-disable-next-line @typescript-eslint/no-explicit-any
+  | ((data: DataType) => any);
+
+/**
+ * A mapping configuration that transforms data from one structure to another.
+ *
+ * This type defines how to map fields from your data structure to the fields
+ * expected by an evaluator or other component. The mapping is flexible and
+ * supports multiple extraction methods.
+ *
+ * **Key Features:**
+ * - Preserves original data fields
+ * - Adds/overrides fields with mapped values
+ * - Supports nested property access
+ * - Supports array element access
+ * - Supports JSONPath expressions for complex queries
+ * - Supports function-based transformations
+ *
+ * @example
+ * **Basic field mapping:**
+ * ```typescript
+ * type MyData = {
+ *   userQuery: string;
+ *   context: string;
+ *   response: string;
+ * };
+ *
+ * const mapping: ObjectMapping<MyData> = {
+ *   input: "userQuery",      // Map "input" to "userQuery"
+ *   reference: "context",    // Map "reference" to "context"
+ *   output: "response",       // Map "output" to "response"
+ * };
+ * ```
+ *
+ * @example
+ * **Nested property mapping:**
+ * ```typescript
+ * type ApiData = {
+ *   request: {
+ *     body: {
+ *       query: string;
+ *       context: string;
+ *     };
+ *   };
+ *   response: {
+ *     data: {
+ *       text: string;
+ *     };
+ *   };
+ * };
+ *
+ * const mapping: ObjectMapping<ApiData> = {
+ *   input: "request.body.query",
+ *   reference: "request.body.context",
+ *   output: "response.data.text",
+ * };
+ * ```
+ *
+ * @example
+ * **Array element access:**
+ * ```typescript
+ * type DataWithArrays = {
+ *   messages: Array<{ role: string; content: string }>;
+ *   sources: string[];
+ * };
+ *
+ * const mapping: ObjectMapping<DataWithArrays> = {
+ *   firstMessage: "messages[0].content",
+ *   lastSource: "sources[-1]",  // Last element
+ *   allRoles: "$.messages[*].role",  // JSONPath for all roles
+ * };
+ * ```
+ *
+ * @example
+ * **Function-based transformations:**
+ * ```typescript
+ * type RawData = {
+ *   firstName: string;
+ *   lastName: string;
+ *   contexts: string[];
+ *   scores: number[];
+ * };
+ *
+ * const mapping: ObjectMapping<RawData> = {
+ *   // Combine fields
+ *   fullName: (data) => `${data.firstName} ${data.lastName}`,
+ *   // Transform array to string
+ *   contextText: (data) => data.contexts.join("\n\n"),
+ *   // Calculate derived value
+ *   averageScore: (data) =>
+ *     data.scores.reduce((a, b) => a + b, 0) / data.scores.length,
+ *   // Conditional logic
+ *   status: (data) => data.scores.length > 0 ? "active" : "inactive",
+ * };
+ * ```
+ *
+ * @example
+ * **Mixed mapping types:**
+ * ```typescript
+ * type ComplexData = {
+ *   user: {
+ *     name: string;
+ *     email: string;
+ *   };
+ *   items: Array<{ id: number; name: string }>;
+ *   metadata: {
+ *     tags: string[];
+ *   };
+ * };
+ *
+ * const mapping: ObjectMapping<ComplexData> = {
+ *   // Simple dot notation
+ *   userName: "user.name",
+ *   // Array access
+ *   firstItemId: "items[0].id",
+ *   // JSONPath for complex query
+ *   allItemNames: "$.items[*].name",
+ *   // Function for transformation
+ *   formattedTags: (data) => data.metadata.tags.map(t => `#${t}`).join(" "),
+ * };
+ * ```
+ *
+ * @example
+ * **Real-world evaluator binding:**
+ * ```typescript
+ * import { bindEvaluator, createHallucinationEvaluator } from "@arizeai/phoenix-evals";
+ *
+ * type QAData = {
+ *   question: string;
+ *   context: string;
+ *   answer: string;
+ * };
+ *
+ * const mapping: ObjectMapping<QAData> = {
+ *   input: "question",      // Evaluator expects "input"
+ *   reference: "context",   // Evaluator expects "reference"
+ *   output: "answer",       // Evaluator expects "output"
+ * };
+ *
+ * const evaluator = bindEvaluator(
+ *   createHallucinationEvaluator({ model: openai("gpt-4") }),
+ *   { inputMapping: mapping }
+ * );
+ * ```
+ *
+ * @typeParam DataType - The type of the data object being mapped
+ */
+export type ObjectMapping<DataType extends Record<string, unknown>> = Record<
+  string,
+  ValueGetter<DataType>
+>;

package/src/types/evals.ts

@@ -1,3 +1,4 @@
+import { ObjectMapping } from "./data";
 import { WithTelemetry } from "./otel";
 import { PromptTemplate } from "./templating";
 
@@ -81,22 +82,41 @@ export interface CreateClassifierArgs extends WithTelemetry {
   promptTemplate: PromptTemplate;
 }
 
-export interface CreateEvaluatorArgs {
+export interface CreateEvaluatorArgs<
+  ExampleType extends Record<string, unknown> = Record<string, unknown>,
+> extends WithTelemetry {
   /**
    * The name of the metric that the evaluator produces
    * E.x. "correctness"
    */
   name: string;
+  /**
+   * The kind of the evaluation. Also known as the "kind" of evaluator.
+   */
+  kind: EvaluationKind;
   /**
    * If present, represents the direction in which you want the metric to be optimized
    * E.x. "MAXIMIZE" means you want the number to be higher.
    */
   optimizationDirection?: OptimizationDirection;
+  /**
+   * The mapping of the input to evaluate to the shape that the evaluator expects
+   */
+  inputMapping?: ObjectMapping<ExampleType>;
 }
 
-export interface CreateClassificationEvaluatorArgs
-  extends CreateClassifierArgs,
-    CreateEvaluatorArgs {}
+export type CreateLLMEvaluatorArgs<RecordType extends Record<string, unknown>> =
+  Omit<CreateEvaluatorArgs<RecordType>, "kind">;
+
+export interface CreateClassificationEvaluatorArgs<
+  RecordType extends Record<string, unknown>,
+> extends CreateClassifierArgs,
+    CreateLLMEvaluatorArgs<RecordType> {
+  /**
+   * The prompt template to use for classification
+   */
+  promptTemplate: PromptTemplate;
+}
 
 export type EvaluatorFn<ExampleType extends Record<string, unknown>> = (
   args: ExampleType
@@ -136,7 +156,7 @@ interface EvaluatorDescription {
  * The Base Evaluator interface
  * This is the interface that all evaluators must implement
  */
-export interface Evaluator<ExampleType extends Record<string, unknown>>
+export interface EvaluatorInterface<ExampleType extends Record<string, unknown>>
   extends EvaluatorDescription {
   /**
    * The function that evaluates the example

package/src/types/index.ts

@@ -1,3 +1,4 @@
 export * from "./evals";
 export * from "./templating";
 export * from "./otel";
+export * from "./data";

package/src/types/otel.ts

@@ -1,17 +1,19 @@
 import { Tracer } from "@opentelemetry/api";
 
+export type TelemetryConfig = {
+  /**
+   * Whether OpenTelemetry is enabled on the call.
+   * Defaults to true for visibility into the evals calls.
+   * @default true
+   */
+  isEnabled?: boolean;
+  /**
+   * The tracer to use for the call.
+   * If not provided, the traces will get picked up by the global tracer.
+   */
+  tracer?: Tracer;
+};
+
 export type WithTelemetry = {
-  telemetry?: {
-    /**
-     * Whether OpenTelemetry is enabled on the call.
-     * Defaults to true for visibility into the evals calls.
-     * @default true
-     */
-    isEnabled?: boolean;
-    /**
-     * The tracer to use for the call.
-     * If not provided, the traces will get picked up by the global tracer.
-     */
-    tracer?: Tracer;
-  };
+  telemetry?: TelemetryConfig;
 };