Reference

npm install zeroeval

function init(opts?: InitOptions): void

import * as ze from 'zeroeval';

ze.init({
  apiKey: 'your-api-key',
  debug: true
});

function wrap<T extends object>(client: T): WrappedClient<T>

// OpenAI
import { OpenAI } from 'openai';
import * as ze from 'zeroeval';

const openai = ze.wrap(new OpenAI());

// Vercel AI SDK
import * as ai from 'ai';
import * as ze from 'zeroeval';

const wrappedAI = ze.wrap(ai);

function withSpan<T>(
  opts: SpanOptions,
  fn: () => Promise<T> | T
): Promise<T> | T

import * as ze from 'zeroeval';

const result = await ze.withSpan(
  { name: 'fetch-user-data' },
  async () => {
    const user = await fetchUser(userId);
    return user;
  }
);

span(opts: SpanOptions): MethodDecorator

import * as ze from 'zeroeval';

class UserService {
  @ze.span({ name: 'get-user' })
  async getUser(id: string): Promise<User> {
    return await db.users.findById(id);
  }
}

function getCurrentSpan(): Span | undefined

function getCurrentTrace(): string | undefined

function getCurrentSession(): string | undefined

function setTag(
  target: Span | string | undefined,
  tags: Record<string, string>
): void

async function prompt(options: PromptOptions): Promise<string>

import * as ze from 'zeroeval';

// Auto-optimization mode (recommended)
const prompt = await ze.prompt({
  name: 'customer-support',
  content: 'You are a helpful {{role}} assistant.',
  variables: { role: 'customer service' }
});

// Explicit mode - bypass auto-optimization
const prompt = await ze.prompt({
  name: 'customer-support',
  content: 'You are a helpful assistant.',
  from: 'explicit'
});

// Latest mode - require optimized version
const prompt = await ze.prompt({
  name: 'customer-support',
  from: 'latest'
});

// Hash mode - specific version
const prompt = await ze.prompt({
  name: 'customer-support',
  from: 'a1b2c3d4e5f6...'  // 64-char SHA-256 hash
});

<zeroeval>{"task":"...", "prompt_version": 1, ...}</zeroeval>Your prompt content here

async function sendFeedback(options: SendFeedbackOptions): Promise<PromptFeedbackResponse>

import * as ze from 'zeroeval';

await ze.sendFeedback({
  promptSlug: 'support-bot',
  completionId: '550e8400-e29b-41d4-a716-446655440000',
  thumbsUp: false,
  reason: 'Response was too verbose',
  expectedOutput: 'A concise 2-3 sentence response'
});

async function sendSignal(
  entityType: 'session' | 'trace' | 'span' | 'completion',
  entityId: string,
  name: string,
  value: string | boolean | number,
  signalType?: 'boolean' | 'numerical'
): Promise<void>

function sendTraceSignal(
  name: string,
  value: string | boolean | number,
  signalType?: 'boolean' | 'numerical'
): void

function sendSessionSignal(
  name: string,
  value: string | boolean | number,
  signalType?: 'boolean' | 'numerical'
): void

function sendSpanSignal(
  name: string,
  value: string | boolean | number,
  signalType?: 'boolean' | 'numerical'
): void

async function getEntitySignals(
  entityType: 'session' | 'trace' | 'span' | 'completion',
  entityId: string
): Promise<Signal[]>

import * as ze from 'zeroeval';

await ze.withSpan({ name: 'process-request' }, async () => {
  // Process something...
  
  // Send signals
  ze.sendSpanSignal('success', true);
  ze.sendSpanSignal('latency_ms', 150);
  ze.sendTraceSignal('user_satisfied', true);
});

function renderTemplate(
  template: string,
  variables: Record<string, string | number | boolean>,
  options?: { ignoreMissing?: boolean }
): string

function extractVariables(template: string): Set<string>

async function sha256Hex(text: string): Promise<string>

function normalizePromptText(text: string): string

class PromptNotFoundError extends Error {
  constructor(message: string)
}

class PromptRequestError extends Error {
  constructor(message: string, statusCode?: number)
}

interface Prompt {
  id: string;
  prompt_id: string;
  content: string;
  content_hash: string;
  version: number;
  model_id?: string;
}

interface PromptMetadata {
  task: string;
  prompt_slug?: string;
  prompt_version?: number;
  prompt_version_id?: string;
  content_hash?: string;
  variables?: Record<string, string>;
}

interface Signal {
  value: string | boolean | number;
  type: 'boolean' | 'numerical';
}