@posthog/ai/dist/otel/index.d.ts

PostHog Node.js AI integrations

import { PostHog } from 'posthog-node';
import { ReadableSpan, SpanProcessor } from '@opentelemetry/sdk-trace-base';
import { Span, Context } from '@opentelemetry/api';

interface CostOverride {
    inputCost: number;
    outputCost: number;
}
declare enum AIEvent {
    Generation = "$ai_generation",
    Embedding = "$ai_embedding"
}

type UsageData = Record<string, unknown>;
interface PostHogSpanMapperContext {
    options: PostHogTelemetryOptions;
}
interface PostHogSpanMapperResult {
    distinctId?: string;
    traceId?: string;
    model?: string;
    provider: string;
    input: any;
    output: any;
    latency: number;
    timeToFirstToken?: number;
    baseURL?: string;
    httpStatus?: number;
    eventType?: AIEvent;
    usage?: UsageData;
    tools?: any[] | null;
    modelParams?: Record<string, unknown>;
    posthogProperties?: Record<string, unknown>;
    error?: unknown;
}
interface PostHogSpanMapper {
    name: string;
    canMap: (span: ReadableSpan) => boolean;
    map: (span: ReadableSpan, context: PostHogSpanMapperContext) => PostHogSpanMapperResult | null;
}
type ShouldExportSpan = (params: {
    otelSpan: ReadableSpan;
}) => boolean;
interface PostHogTelemetryOptions {
    posthogDistinctId?: string;
    posthogTraceId?: string;
    posthogProperties?: Record<string, any>;
    posthogPrivacyMode?: boolean;
    posthogGroups?: Record<string, any>;
    posthogModelOverride?: string;
    posthogProviderOverride?: string;
    posthogCostOverride?: CostOverride;
    posthogCaptureImmediate?: boolean;
    mappers?: PostHogSpanMapper[];
    shouldExportSpan?: ShouldExportSpan;
}
type PostHogReadableSpan = ReadableSpan;
type PostHogTelemetrySpanProcessor = SpanProcessor;

declare function captureSpan(span: ReadableSpan, phClient: PostHog, options?: PostHogTelemetryOptions): Promise<void>;

declare class PostHogSpanProcessor implements SpanProcessor {
    private readonly phClient;
    private readonly options;
    private readonly pendingCaptures;
    constructor(phClient: PostHog, options?: PostHogTelemetryOptions);
    onStart(_span: Span, _parentContext: Context): void;
    onEnd(span: ReadableSpan): void;
    shutdown(): Promise<void>;
    forceFlush(): Promise<void>;
}
declare function createPostHogSpanProcessor(phClient: PostHog, options?: PostHogTelemetryOptions): SpanProcessor;

declare const aiSdkSpanMapper: PostHogSpanMapper;

export { type PostHogReadableSpan, type PostHogSpanMapper, type PostHogSpanMapperResult, PostHogSpanProcessor, type PostHogTelemetryOptions, type PostHogTelemetrySpanProcessor, type ShouldExportSpan, aiSdkSpanMapper, captureSpan, createPostHogSpanProcessor };