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 getCurrentSpan(): Span | undefined

function getCurrentTrace(): string | undefined

function getCurrentSession(): string | undefined

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

// Set tags on current span
ze.setTag(undefined, { user_id: '12345', environment: 'production' });

// Set tags on specific trace
const traceId = ze.getCurrentTrace();
if (traceId) {
  ze.setTag(traceId, { feature: 'checkout' });
}

// Set tags on a span object
const span = ze.getCurrentSpan();
if (span) {
  ze.setTag(span, { action: 'process_payment' });
}

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

import * as ze from 'zeroeval';

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

// With session and tags
const data = ze.withSpan(
  {
    name: 'process-payment',
    sessionId: sessionId,
    tags: { environment: 'production', version: '1.0' }
  },
  () => processPayment(amount)
);

span(opts: SpanOptions): MethodDecorator

import * as ze from 'zeroeval';

class UserService {
  @ze.span({ name: 'get-user' })
  async getUser(id: string): Promise<User> {
    // Method implementation
    // Input (id) and output (User) are automatically captured
    return await db.users.findById(id);
  }

  @ze.span({ 
    name: 'update-user',
    tags: { operation: 'update' }
  })
  async updateUser(id: string, data: Partial<User>): Promise<User> {
    return await db.users.update(id, data);
  }
}

{
  "compilerOptions": {
    "experimentalDecorators": true
  }
}

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[]>

class ZeroEvalCallbackHandler extends BaseCallbackHandler

constructor(options?: ZeroEvalCallbackHandlerOptions)

import { ZeroEvalCallbackHandler } from 'zeroeval/langchain';

const handler = new ZeroEvalCallbackHandler({
  debug: true,
  maxConcurrentSpans: 500
});

// Use with LangChain
const chain = new ConversationChain({
  callbacks: [handler]
});

function setGlobalCallbackHandler(handler: ZeroEvalCallbackHandler): void

function getGlobalHandler(): BaseCallbackHandler | undefined

function clearGlobalHandler(): void

interface InitOptions {
  apiKey?: string;
  apiUrl?: string;
  workspaceName?: string;
  flushInterval?: number;
  maxSpans?: number;
  collectCodeDetails?: boolean;
  integrations?: Record<string, boolean>;
  debug?: boolean;
}

interface SignalCreate {
  entity_type: 'session' | 'trace' | 'span' | 'completion';
  entity_id: string;
  name: string;
  value: string | boolean | number;
  signal_type?: 'boolean' | 'numerical';
}

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

interface ZeroEvalCallbackHandlerOptions {
  debug?: boolean;
  excludeMetadataProps?: RegExp;
  maxConcurrentSpans?: number;
  spanCleanupIntervalMs?: number;
}