ai-functions/dist/telemetry.d.ts

Core AI primitives for building intelligent applications

/**
 * OpenTelemetry Integration for ai-functions
 *
 * Provides instrumented wrappers and telemetry utilities for AI function calls.
 *
 * @example
 * ```ts
 * import { withTelemetry, instrumentGenerate } from 'ai-functions/telemetry'
 *
 * // Enable telemetry globally
 * withTelemetry({ provider: createConsoleTelemetryProvider() }, async () => {
 *   const text = await generate('Explain quantum computing')
 * })
 *
 * // Or instrument individual functions
 * const traced = instrumentGenerate(generate)
 * const text = await traced('Explain quantum computing')
 * ```
 *
 * @packageDocumentation
 */
import { type Tracer, type Meter, type Logger, type Span, type SpanAttributes, type TelemetryProvider, type Counter, type Histogram } from '@org.ai/types';
/**
 * Get the tracer for ai-functions
 */
export declare function getFunctionsTracer(): Tracer;
/**
 * Get the meter for ai-functions
 */
export declare function getFunctionsMeter(): Meter;
/**
 * Get the logger for ai-functions
 */
export declare function getFunctionsLogger(): Logger;
/**
 * Get AI metrics for the package
 */
export declare function getAIMetrics(): {
    requestDuration: Histogram;
    requestTotal: Counter;
    requestErrors: Counter;
    tokensUsed: Counter;
    costTotal: Counter;
};
/**
 * Reset cached telemetry instances (useful after changing provider)
 */
export declare function resetTelemetry(): void;
/**
 * Options for withTelemetry
 */
export interface WithTelemetryOptions {
    /** Telemetry provider to use */
    provider?: TelemetryProvider;
    /** Service name for telemetry */
    serviceName?: string;
    /** Service version */
    serviceVersion?: string;
}
/**
 * Execute a function with telemetry enabled
 *
 * @example
 * ```ts
 * import { createConsoleTelemetryProvider } from '@org.ai/types'
 *
 * await withTelemetry({
 *   provider: createConsoleTelemetryProvider()
 * }, async () => {
 *   const text = await generate('Hello')
 * })
 * ```
 */
export declare function withTelemetry<T>(options: WithTelemetryOptions, fn: () => Promise<T>): Promise<T>;
/**
 * Record AI request metrics
 */
export declare function recordAIRequest(params: {
    model: string;
    provider: string;
    inputTokens: number;
    outputTokens: number;
    durationMs: number;
    success: boolean;
    costUsd?: number | undefined;
}): void;
/**
 * Create a traced version of any async function
 */
export declare function traced<TArgs extends unknown[], TResult>(name: string, fn: (...args: TArgs) => Promise<TResult>, options?: {
    kind?: 'internal' | 'client' | 'server';
    getAttributes?: (...args: TArgs) => SpanAttributes;
}): (...args: TArgs) => Promise<TResult>;
/**
 * Create instrumented generate function
 *
 * @example
 * ```ts
 * import { generate } from 'ai-functions'
 * import { instrumentGenerate } from 'ai-functions/telemetry'
 *
 * const tracedGenerate = instrumentGenerate(generate)
 * const result = await tracedGenerate('text', 'Hello world')
 * ```
 */
export declare function instrumentGenerate<T extends (...args: any[]) => Promise<any>>(generateFn: T): T;
/**
 * Create instrumented AI function with full metrics
 */
export declare function instrumentAIFunction<TInput, TOutput>(name: string, fn: (input: TInput) => Promise<TOutput>, options?: {
    model?: string;
    provider?: string;
    getTokens?: (input: TInput, output: TOutput) => {
        input: number;
        output: number;
    };
    getCost?: (input: TInput, output: TOutput) => number;
}): (input: TInput) => Promise<TOutput>;
/**
 * Start a span for an AI operation
 */
export declare function startAISpan(name: string, attributes?: SpanAttributes): Span;
/**
 * Execute code within a span
 */
export declare function withAISpan<T>(name: string, fn: (span: Span) => Promise<T>, attributes?: SpanAttributes): Promise<T>;
export { type Tracer, type Meter, type Logger, type Span, type SpanAttributes, type TelemetryProvider, type Counter, type Histogram, getTracer, getMeter, getLogger, setTelemetryProvider, getTelemetryProvider, SemanticAttributes, MetricNames, createAIMetrics, } from '@org.ai/types';
//# sourceMappingURL=telemetry.d.ts.map