Reference

npm install zeroeval

function init(opts?: InitOptions): void;

import * as ze from "zeroeval";

ze.init({
  apiKey: "your-api-key",
  redaction: { enabled: true },
  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);

// Claude Agent SDK
import * as ze from "zeroeval";

const claudeAgentSdk = await import("@anthropic-ai/claude-agent-sdk");
const sdk = ze.wrap(claudeAgentSdk);

function wrapClaudeAgentSdk<T extends object>(module: T): T;

import * as ze from "zeroeval";

const claudeAgentSdk = await import("@anthropic-ai/claude-agent-sdk");
const sdk = ze.wrapClaudeAgentSdk(claudeAgentSdk);

for await (const message of sdk.query({ prompt: "Hello!" })) {
  // each query() call is traced as a claude_agent.query span
}

function wrapClaudeAgentQuery(queryFn: QueryFn): QueryFn;

import { query } from "@anthropic-ai/claude-agent-sdk";
import * as ze from "zeroeval";

const tracedQuery = ze.wrapClaudeAgentQuery(query);

for await (const message of tracedQuery({ prompt: "Hello!" })) {
  // traced as a claude_agent.query span
}

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",
});

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>;
}

export ZEROEVAL_API_KEY="ze_1234567890abcdef"
export ZEROEVAL_SAMPLING_RATE="0.1"
export ZEROEVAL_DEBUG="true"

ze.init({
  apiKey: "your_key",
  flushInterval: 1,
  maxSpans: 200,
  debug: false,
  integrations: {
    openai: true,
    vercelAI: true,
    claudeAgent: true,
  },
});

ze.init({
  apiKey: "your_key",
  debug: true,
  collectCodeDetails: true,
});