autotel 3.6.0 → 4.0.0

package/src/gen-ai-cost.test.ts

@@ -1,81 +0,0 @@
-import { describe, it, expect, vi } from 'vitest';
-import {
-  estimateLLMCost,
-  recordLLMCost,
-  GEN_AI_COST_ATTRIBUTE,
-} from './gen-ai-cost';
-
-describe('estimateLLMCost', () => {
-  it('estimates cost from input and output tokens', () => {
-    // claude-sonnet-4: $3 / 1M in, $15 / 1M out
-    const cost = estimateLLMCost('claude-sonnet-4', {
-      inputTokens: 1_000_000,
-      outputTokens: 1_000_000,
-    });
-    expect(cost).toBe(18);
-  });
-
-  it('matches versioned model ids by longest prefix', () => {
-    const cost = estimateLLMCost('claude-sonnet-4-6-20251101', {
-      inputTokens: 1_000_000,
-      outputTokens: 0,
-    });
-    expect(cost).toBe(3);
-  });
-
-  it('returns undefined for an unknown model', () => {
-    expect(
-      estimateLLMCost('totally-made-up', { inputTokens: 1000 }),
-    ).toBeUndefined();
-  });
-
-  it('bills cached input tokens at the cached rate', () => {
-    const pricing = {
-      custom: { inputPer1M: 10, outputPer1M: 30, cachedInputPer1M: 1 },
-    };
-    // 1M input, of which 800k cached: 200k @ $10/M + 800k @ $1/M = 2 + 0.8
-    const cost = estimateLLMCost(
-      'custom',
-      { inputTokens: 1_000_000, cachedInputTokens: 800_000 },
-      { pricing },
-    );
-    expect(cost).toBeCloseTo(2.8, 6);
-  });
-
-  it('accepts a pricing override and extends the table', () => {
-    const cost = estimateLLMCost(
-      'my-model',
-      { inputTokens: 500_000, outputTokens: 500_000 },
-      { pricing: { 'my-model': { inputPer1M: 4, outputPer1M: 8 } } },
-    );
-    expect(cost).toBe(6);
-  });
-
-  it('handles partial usage without throwing', () => {
-    expect(estimateLLMCost('gpt-4o-mini', {})).toBe(0);
-    expect(estimateLLMCost('gpt-4o-mini', { outputTokens: 1_000_000 })).toBe(
-      0.6,
-    );
-  });
-});
-
-describe('recordLLMCost', () => {
-  it('sets the cost attribute on the context for a known model', () => {
-    const setAttribute = vi.fn();
-    const cost = recordLLMCost({ setAttribute }, 'gpt-4o', {
-      inputTokens: 1_000_000,
-      outputTokens: 0,
-    });
-    expect(cost).toBe(2.5);
-    expect(setAttribute).toHaveBeenCalledWith(GEN_AI_COST_ATTRIBUTE, 2.5);
-  });
-
-  it('sets no attribute for an unknown model', () => {
-    const setAttribute = vi.fn();
-    const cost = recordLLMCost({ setAttribute }, 'unknown-model', {
-      inputTokens: 100,
-    });
-    expect(cost).toBeUndefined();
-    expect(setAttribute).not.toHaveBeenCalled();
-  });
-});

package/src/gen-ai-cost.ts

@@ -1,145 +0,0 @@
-/**
- * Per-model LLM cost estimation.
- *
- * Estimate the USD cost of an LLM call from its token usage and record it as a
- * span attribute (`gen_ai.usage.cost.usd`). Pair with the
- * `gen_ai.client.cost.usd` metric bucket advice in `gen-ai-metrics`.
- *
- * @example
- * ```typescript
- * import { trace, recordLLMCost } from 'autotel';
- *
- * export const chat = trace((ctx) => async (prompt: string) => {
- *   const res = await client.messages.create({ model, ... });
- *   recordLLMCost(ctx, model, {
- *     inputTokens: res.usage.input_tokens,
- *     outputTokens: res.usage.output_tokens,
- *   });
- *   return res;
- * });
- * ```
- */
-
-import type { TraceContext } from './trace-context';
-
-/** Span attribute key autotel sets for an estimated call cost. */
-export const GEN_AI_COST_ATTRIBUTE = 'gen_ai.usage.cost.usd';
-
-/** Pricing for a single model, in USD per 1,000,000 tokens. */
-export interface ModelPricing {
-  /** USD per 1M input (prompt) tokens. */
-  inputPer1M: number;
-  /** USD per 1M output (completion) tokens. */
-  outputPer1M: number;
-  /** USD per 1M cached input tokens. Defaults to {@link ModelPricing.inputPer1M}. */
-  cachedInputPer1M?: number;
-}
-
-/** Token counts for a single LLM call. */
-export interface TokenUsage {
-  inputTokens?: number;
-  outputTokens?: number;
-  /** Cached input tokens, billed at {@link ModelPricing.cachedInputPer1M}. */
-  cachedInputTokens?: number;
-}
-
-export interface EstimateCostOptions {
-  /** Override or extend {@link MODEL_PRICING}. Keys are matched first. */
-  pricing?: Record<string, ModelPricing>;
-}
-
-/**
- * Approximate public list prices (USD per 1M tokens) at the time of writing.
- * Prices change; treat these as convenience defaults, not a billing source of
- * truth. Override per call via `options.pricing` or mutate this table at init.
- * Matching is exact first, then by longest key prefix, so versioned model ids
- * (`claude-sonnet-4-6-20251101`) resolve to a base entry (`claude-sonnet-4-6`).
- */
-export const MODEL_PRICING: Record<string, ModelPricing> = {
-  // OpenAI
-  'gpt-4o': { inputPer1M: 2.5, outputPer1M: 10 },
-  'gpt-4o-mini': { inputPer1M: 0.15, outputPer1M: 0.6 },
-  'gpt-4.1': { inputPer1M: 2, outputPer1M: 8 },
-  'gpt-4.1-mini': { inputPer1M: 0.4, outputPer1M: 1.6 },
-  'gpt-4.1-nano': { inputPer1M: 0.1, outputPer1M: 0.4 },
-  'o3-mini': { inputPer1M: 1.1, outputPer1M: 4.4 },
-  // Anthropic Claude
-  'claude-opus-4': { inputPer1M: 15, outputPer1M: 75 },
-  'claude-sonnet-4': { inputPer1M: 3, outputPer1M: 15 },
-  'claude-3-5-sonnet': { inputPer1M: 3, outputPer1M: 15 },
-  'claude-3-5-haiku': { inputPer1M: 0.8, outputPer1M: 4 },
-  'claude-3-opus': { inputPer1M: 15, outputPer1M: 75 },
-  'claude-3-haiku': { inputPer1M: 0.25, outputPer1M: 1.25 },
-  // Google Gemini
-  'gemini-1.5-pro': { inputPer1M: 1.25, outputPer1M: 5 },
-  'gemini-1.5-flash': { inputPer1M: 0.075, outputPer1M: 0.3 },
-  'gemini-2.0-flash': { inputPer1M: 0.1, outputPer1M: 0.4 },
-};
-
-function resolvePricing(
-  table: Record<string, ModelPricing>,
-  model: string,
-): ModelPricing | undefined {
-  const exact = table[model];
-  if (exact) return exact;
-
-  let best: ModelPricing | undefined;
-  let bestLength = 0;
-  for (const key of Object.keys(table)) {
-    if (model.startsWith(key) && key.length > bestLength) {
-      best = table[key];
-      bestLength = key.length;
-    }
-  }
-  return best;
-}
-
-function round(value: number): number {
-  return Math.round(value * 1e6) / 1e6;
-}
-
-/**
- * Estimate the USD cost of an LLM call. Returns `undefined` when the model has
- * no known pricing (supply one via `options.pricing`).
- */
-export function estimateLLMCost(
-  model: string,
-  usage: TokenUsage,
-  options?: EstimateCostOptions,
-): number | undefined {
-  const table = options?.pricing
-    ? { ...MODEL_PRICING, ...options.pricing }
-    : MODEL_PRICING;
-  const price = resolvePricing(table, model);
-  if (!price) return undefined;
-
-  const cachedInput = usage.cachedInputTokens ?? 0;
-  const billedInput = Math.max(0, (usage.inputTokens ?? 0) - cachedInput);
-  const output = usage.outputTokens ?? 0;
-  const cachedRate = price.cachedInputPer1M ?? price.inputPer1M;
-
-  const cost =
-    (billedInput / 1_000_000) * price.inputPer1M +
-    (cachedInput / 1_000_000) * cachedRate +
-    (output / 1_000_000) * price.outputPer1M;
-
-  return round(cost);
-}
-
-/**
- * Estimate cost and record it on `ctx` as the `gen_ai.usage.cost.usd` span
- * attribute. Returns the estimated cost, or `undefined` when the model is
- * unknown (in which case no attribute is set).
- */
-export function recordLLMCost(
-  ctx: Pick<TraceContext, 'setAttribute'>,
-  model: string,
-  usage: TokenUsage,
-  options?: EstimateCostOptions,
-): number | undefined {
-  const cost = estimateLLMCost(model, usage, options);
-  if (cost !== undefined) {
-    ctx.setAttribute(GEN_AI_COST_ATTRIBUTE, cost);
-  }
-  return cost;
-}

package/src/gen-ai-events.test.ts

@@ -1,135 +0,0 @@
-import { describe, expect, it } from 'vitest';
-import type { TraceContext } from './trace-context';
-import {
-  recordPromptSent,
-  recordResponseReceived,
-  recordRetry,
-  recordStreamFirstToken,
-  recordToolCall,
-} from './gen-ai-events';
-
-type CapturedEvent = { name: string; attrs?: Record<string, unknown> };
-
-function captureCtx(): {
-  ctx: TraceContext;
-  events: CapturedEvent[];
-} {
-  const events: CapturedEvent[] = [];
-  const ctx = {
-    addEvent: (name: string, attrs?: Record<string, unknown>) => {
-      events.push({ name, attrs });
-    },
-    setAttribute: () => {},
-    setAttributes: () => {},
-    setStatus: () => {},
-    recordException: () => {},
-    addLink: () => {},
-    addLinks: () => {},
-    updateName: () => {},
-    isRecording: () => true,
-    end: () => {},
-  } as unknown as TraceContext;
-  return { ctx, events };
-}
-
-describe('GenAI span event helpers', () => {
-  it('recordPromptSent emits gen_ai.prompt.sent with canonical attrs', () => {
-    const { ctx, events } = captureCtx();
-    recordPromptSent(ctx, {
-      model: 'gpt-4o',
-      promptTokens: 1200,
-      messageCount: 3,
-      operation: 'chat',
-    });
-    expect(events).toHaveLength(1);
-    expect(events[0]).toEqual({
-      name: 'gen_ai.prompt.sent',
-      attrs: {
-        'gen_ai.request.model': 'gpt-4o',
-        'gen_ai.usage.input_tokens': 1200,
-        'gen_ai.request.message_count': 3,
-        'gen_ai.operation.name': 'chat',
-      },
-    });
-  });
-
-  it('recordPromptSent omits unset fields rather than writing undefined', () => {
-    const { ctx, events } = captureCtx();
-    recordPromptSent(ctx);
-    expect(events[0]?.attrs).toEqual({});
-  });
-
-  it('recordResponseReceived joins finish reasons into a CSV for attribute compat', () => {
-    const { ctx, events } = captureCtx();
-    recordResponseReceived(ctx, {
-      model: 'gpt-4o-2024-11-20',
-      promptTokens: 1200,
-      completionTokens: 400,
-      totalTokens: 1600,
-      finishReasons: ['stop', 'tool_calls'],
-    });
-    expect(events[0]).toEqual({
-      name: 'gen_ai.response.received',
-      attrs: {
-        'gen_ai.response.model': 'gpt-4o-2024-11-20',
-        'gen_ai.usage.input_tokens': 1200,
-        'gen_ai.usage.output_tokens': 400,
-        'gen_ai.usage.total_tokens': 1600,
-        'gen_ai.response.finish_reasons': 'stop,tool_calls',
-      },
-    });
-  });
-
-  it('recordResponseReceived omits finish_reasons when empty', () => {
-    const { ctx, events } = captureCtx();
-    recordResponseReceived(ctx, { model: 'claude-sonnet-4-6' });
-    expect(events[0]?.attrs).not.toHaveProperty(
-      'gen_ai.response.finish_reasons',
-    );
-  });
-
-  it('recordRetry captures attempt, reason, delay, and status code', () => {
-    const { ctx, events } = captureCtx();
-    recordRetry(ctx, {
-      attempt: 2,
-      reason: 'rate_limit',
-      delayMs: 1000,
-      statusCode: 429,
-    });
-    expect(events[0]).toEqual({
-      name: 'gen_ai.retry',
-      attrs: {
-        'retry.attempt': 2,
-        'retry.reason': 'rate_limit',
-        'retry.delay_ms': 1000,
-        'http.response.status_code': 429,
-      },
-    });
-  });
-
-  it('recordToolCall writes canonical gen_ai.tool.* keys', () => {
-    const { ctx, events } = captureCtx();
-    recordToolCall(ctx, {
-      toolName: 'search_traces',
-      toolCallId: 'call-123',
-      arguments: '{"serviceName":"api"}',
-    });
-    expect(events[0]).toEqual({
-      name: 'gen_ai.tool.call',
-      attrs: {
-        'gen_ai.tool.name': 'search_traces',
-        'gen_ai.tool.call.id': 'call-123',
-        'gen_ai.tool.arguments': '{"serviceName":"api"}',
-      },
-    });
-  });
-
-  it('recordStreamFirstToken is the bare marker for TTFT', () => {
-    const { ctx, events } = captureCtx();
-    recordStreamFirstToken(ctx, { tokensSoFar: 1 });
-    expect(events[0]).toEqual({
-      name: 'gen_ai.stream.first_token',
-      attrs: { 'gen_ai.stream.tokens_so_far': 1 },
-    });
-  });
-});

package/src/gen-ai-events.ts

@@ -1,208 +0,0 @@
-/**
- * Span event helpers for LLM lifecycle, aligned with the OpenTelemetry
- * GenAI semantic conventions.
- *
- * Span events are timestamped points within a span — they render as dots
- * on the trace timeline in Jaeger / Tempo / Langfuse / Arize. Use them
- * to mark lifecycle moments the span attributes alone can't express:
- *
- *   - When the prompt was sent (vs. when the first token arrived)
- *   - When each retry attempt started, and why
- *   - When a streaming response produced its first token (TTFT)
- *   - When a tool was invoked
- *
- * Every helper pins the event name + attribute keys to the published
- * spec so downstream tooling (autotel-mcp, Langfuse, vendor UIs) can
- * render them consistently.
- *
- * @example
- * ```typescript
- * import { trace, recordPromptSent, recordResponseReceived, recordRetry } from 'autotel';
- *
- * export const chat = trace('chat', ctx => async (prompt: string) => {
- *   recordPromptSent(ctx, { model: 'gpt-4o', messageCount: 1 });
- *
- *   for (let attempt = 1; attempt <= 3; attempt++) {
- *     try {
- *       const res = await openai.chat.completions.create({...});
- *       recordResponseReceived(ctx, {
- *         model: res.model,
- *         promptTokens: res.usage?.prompt_tokens,
- *         completionTokens: res.usage?.completion_tokens,
- *         finishReasons: res.choices.map(c => c.finish_reason),
- *       });
- *       return res;
- *     } catch (err) {
- *       recordRetry(ctx, { attempt, reason: 'rate_limit', delayMs: 500 });
- *       await sleep(500 * attempt);
- *     }
- *   }
- * });
- * ```
- */
-
-import type { TraceContext } from './trace-context';
-import { emitCorrelatedEvent } from './correlated-events';
-
-type EventAttrs = Record<string, string | number | boolean>;
-
-/** Attributes expected on a `gen_ai.prompt.sent` event. */
-export interface PromptSentEvent {
-  /** Model the caller intends to invoke (may differ from response model). */
-  model?: string;
-  /** Estimated input token count, when known before the call. */
-  promptTokens?: number;
-  /** Number of messages in a chat request (system + user + assistant). */
-  messageCount?: number;
-  /** Free-form operation kind — `chat` / `completion` / `embedding`. */
-  operation?: string;
-}
-
-/** Attributes expected on a `gen_ai.response.received` event. */
-export interface ResponseReceivedEvent {
-  /** Model the provider actually served (may be more specific than requested). */
-  model?: string;
-  promptTokens?: number;
-  completionTokens?: number;
-  totalTokens?: number;
-  /** `stop`, `length`, `content_filter`, `tool_calls`, etc. */
-  finishReasons?: string[];
-}
-
-/** Attributes expected on a `gen_ai.retry` event. */
-export interface RetryEvent {
-  attempt: number;
-  /** `rate_limit` | `timeout` | `provider_error` | custom label. */
-  reason?: string;
-  /** How long we'll wait before the next attempt. */
-  delayMs?: number;
-  /** HTTP status that triggered the retry, when applicable. */
-  statusCode?: number;
-}
-
-/** Attributes expected on a `gen_ai.tool.call` event. */
-export interface ToolCallEvent {
-  toolName: string;
-  /** Call identifier so responses can be correlated back to calls. */
-  toolCallId?: string;
-  /** Pre-serialised tool arguments; omit if sensitive. */
-  arguments?: string;
-}
-
-/** Attributes expected on a `gen_ai.stream.first_token` event. */
-export interface StreamFirstTokenEvent {
-  /** Tokens streamed so far, if the caller tracks that. */
-  tokensSoFar?: number;
-}
-
-/**
- * Record that a prompt was dispatched to the provider. Typically called
- * before `await provider.chat.completions.create(...)`.
- */
-export function recordPromptSent(
-  ctx: TraceContext,
-  event: PromptSentEvent = {},
-): void {
-  emitCorrelatedEvent(ctx, 'gen_ai.prompt.sent', buildPromptSentAttrs(event));
-}
-
-/**
- * Record a successful provider response. Call after the response arrives
- * (for non-streaming) or after the stream completes.
- */
-export function recordResponseReceived(
-  ctx: TraceContext,
-  event: ResponseReceivedEvent = {},
-): void {
-  emitCorrelatedEvent(
-    ctx,
-    'gen_ai.response.received',
-    buildResponseAttrs(event),
-  );
-}
-
-/**
- * Record a retry attempt on an LLM call. Call *before* sleeping for
- * `delayMs` so the event timestamp accurately marks when the retry
- * decision was made.
- */
-export function recordRetry(ctx: TraceContext, event: RetryEvent): void {
-  emitCorrelatedEvent(ctx, 'gen_ai.retry', buildRetryAttrs(event));
-}
-
-/**
- * Record a tool / function call made in the course of an agent step.
- * Emits an event rather than a child span because many frameworks fire
- * several tool calls within a single provider response.
- */
-export function recordToolCall(ctx: TraceContext, event: ToolCallEvent): void {
-  emitCorrelatedEvent(ctx, 'gen_ai.tool.call', buildToolCallAttrs(event));
-}
-
-/**
- * Record the time-to-first-token for a streaming response. Pair with
- * `recordResponseReceived` at the end so the span carries both the TTFT
- * marker and the final usage numbers.
- */
-export function recordStreamFirstToken(
-  ctx: TraceContext,
-  event: StreamFirstTokenEvent = {},
-): void {
-  emitCorrelatedEvent(
-    ctx,
-    'gen_ai.stream.first_token',
-    buildStreamFirstTokenAttrs(event),
-  );
-}
-
-// ---- Attribute builders -------------------------------------------------
-
-function buildPromptSentAttrs(event: PromptSentEvent): EventAttrs {
-  const attrs: EventAttrs = {};
-  if (event.model) attrs['gen_ai.request.model'] = event.model;
-  if (event.promptTokens !== undefined)
-    attrs['gen_ai.usage.input_tokens'] = event.promptTokens;
-  if (event.messageCount !== undefined)
-    attrs['gen_ai.request.message_count'] = event.messageCount;
-  if (event.operation) attrs['gen_ai.operation.name'] = event.operation;
-  return attrs;
-}
-
-function buildResponseAttrs(event: ResponseReceivedEvent): EventAttrs {
-  const attrs: EventAttrs = {};
-  if (event.model) attrs['gen_ai.response.model'] = event.model;
-  if (event.promptTokens !== undefined)
-    attrs['gen_ai.usage.input_tokens'] = event.promptTokens;
-  if (event.completionTokens !== undefined)
-    attrs['gen_ai.usage.output_tokens'] = event.completionTokens;
-  if (event.totalTokens !== undefined)
-    attrs['gen_ai.usage.total_tokens'] = event.totalTokens;
-  if (event.finishReasons && event.finishReasons.length > 0) {
-    // Arrays aren't primitive AttributeValues on this context, so join.
-    attrs['gen_ai.response.finish_reasons'] = event.finishReasons.join(',');
-  }
-  return attrs;
-}
-
-function buildRetryAttrs(event: RetryEvent): EventAttrs {
-  const attrs: EventAttrs = { 'retry.attempt': event.attempt };
-  if (event.reason) attrs['retry.reason'] = event.reason;
-  if (event.delayMs !== undefined) attrs['retry.delay_ms'] = event.delayMs;
-  if (event.statusCode !== undefined)
-    attrs['http.response.status_code'] = event.statusCode;
-  return attrs;
-}
-
-function buildToolCallAttrs(event: ToolCallEvent): EventAttrs {
-  const attrs: EventAttrs = { 'gen_ai.tool.name': event.toolName };
-  if (event.toolCallId) attrs['gen_ai.tool.call.id'] = event.toolCallId;
-  if (event.arguments) attrs['gen_ai.tool.arguments'] = event.arguments;
-  return attrs;
-}
-
-function buildStreamFirstTokenAttrs(event: StreamFirstTokenEvent): EventAttrs {
-  const attrs: EventAttrs = {};
-  if (event.tokensSoFar !== undefined)
-    attrs['gen_ai.stream.tokens_so_far'] = event.tokensSoFar;
-  return attrs;
-}

package/src/gen-ai-metrics.test.ts

@@ -1,96 +0,0 @@
-import { describe, expect, it } from 'vitest';
-import { AggregationType } from '@opentelemetry/sdk-metrics';
-import {
-  GEN_AI_COST_USD_BUCKETS,
-  GEN_AI_DURATION_BUCKETS_SECONDS,
-  GEN_AI_TOKEN_USAGE_BUCKETS,
-  genAiMetricViews,
-  llmHistogramAdvice,
-} from './gen-ai-metrics';
-
-describe('gen-ai-metrics', () => {
-  it('bucket arrays are strictly ascending (required by Prometheus + OTel)', () => {
-    for (const buckets of [
-      GEN_AI_DURATION_BUCKETS_SECONDS,
-      GEN_AI_TOKEN_USAGE_BUCKETS,
-      GEN_AI_COST_USD_BUCKETS,
-    ]) {
-      for (let i = 1; i < buckets.length; i++) {
-        expect(
-          buckets[i]! > buckets[i - 1]!,
-          `index ${i} not ascending: ${buckets[i - 1]} → ${buckets[i]}`,
-        ).toBe(true);
-      }
-    }
-  });
-
-  it('duration buckets cover tail through 5 minutes for reasoning models', () => {
-    expect(GEN_AI_DURATION_BUCKETS_SECONDS[0]).toBeLessThanOrEqual(0.05);
-    expect(
-      GEN_AI_DURATION_BUCKETS_SECONDS[
-        GEN_AI_DURATION_BUCKETS_SECONDS.length - 1
-      ],
-    ).toBeGreaterThanOrEqual(300);
-  });
-
-  it('token buckets cover up to a million-token context window', () => {
-    expect(
-      GEN_AI_TOKEN_USAGE_BUCKETS[GEN_AI_TOKEN_USAGE_BUCKETS.length - 1],
-    ).toBeGreaterThanOrEqual(1_000_000);
-  });
-
-  it('cost buckets resolve sub-cent spend', () => {
-    expect(GEN_AI_COST_USD_BUCKETS[0]).toBeLessThan(0.001);
-  });
-
-  it('bucket arrays are frozen — consumers cannot mutate shared state', () => {
-    expect(() => {
-      (GEN_AI_DURATION_BUCKETS_SECONDS as number[]).push(999);
-    }).toThrow();
-  });
-
-  it('llmHistogramAdvice returns explicitBucketBoundaries advice shape', () => {
-    const advice = llmHistogramAdvice('duration');
-    expect(advice.advice.explicitBucketBoundaries).toEqual([
-      ...GEN_AI_DURATION_BUCKETS_SECONDS,
-    ]);
-    // The returned array is a fresh copy so callers can mutate without
-    // affecting the shared constant.
-    advice.advice.explicitBucketBoundaries.push(0);
-    expect([...GEN_AI_DURATION_BUCKETS_SECONDS]).not.toContain(0);
-  });
-
-  it('genAiMetricViews targets the OTel GenAI instrument names with the right buckets', () => {
-    const views = genAiMetricViews();
-    expect(views).toHaveLength(3);
-
-    const byInstrument = Object.fromEntries(
-      views.map((v) => [v.instrumentName, v]),
-    );
-    expect(
-      byInstrument['gen_ai.client.operation.duration']?.aggregation,
-    ).toEqual({
-      type: AggregationType.EXPLICIT_BUCKET_HISTOGRAM,
-      options: { boundaries: [...GEN_AI_DURATION_BUCKETS_SECONDS] },
-    });
-    expect(byInstrument['gen_ai.client.token.usage']?.aggregation).toEqual({
-      type: AggregationType.EXPLICIT_BUCKET_HISTOGRAM,
-      options: { boundaries: [...GEN_AI_TOKEN_USAGE_BUCKETS] },
-    });
-    expect(byInstrument['gen_ai.client.cost.usd']?.aggregation).toEqual({
-      type: AggregationType.EXPLICIT_BUCKET_HISTOGRAM,
-      options: { boundaries: [...GEN_AI_COST_USD_BUCKETS] },
-    });
-  });
-
-  it('genAiMetricViews accepts extra instruments', () => {
-    const views = genAiMetricViews([
-      { instrumentName: 'custom.llm.prompt_tokens', kind: 'tokens' },
-    ]);
-    expect(views).toHaveLength(4);
-    const custom = views.find(
-      (v) => v.instrumentName === 'custom.llm.prompt_tokens',
-    );
-    expect(custom).toBeDefined();
-  });
-});