/**
 * Minimal tracing surface — one event per operation of interest.
 *
 * Design bias: pragmatic HTTP wrapper over Langfuse's ingestion API rather
 * than a full OpenTelemetry SDK. Cloudflare Workers can host OTel but the
 * configuration overhead vs. the wire format's simplicity isn't worth it for
 * the "log one trace per agent turn" use case that motivated this.
 *
 * Consumers implement `Tracer` if they want a different backend. Default is
 * `NoOpTracer` (drop all events) so wiring a `tracer?: Tracer` argument into
 * higher-level classes stays free when the env vars aren't set.
 *
 * Typical wire-up:
 *   const tracer = env.LANGFUSE_PUBLIC_KEY
 *     ? new LangfuseTracer({ publicKey, secretKey, host, environment })
 *     : new NoOpTracer();
 *
 *   const t0 = Date.now();
 *   const result = await loop.run({...});
 *   ctx.waitUntil(tracer.flushTrace({
 *     traceId: crypto.randomUUID(),
 *     name: 'agent.turn',
 *     input: { userText },
 *     output: { text: result.text, finishReason: result.finishReason },
 *     metadata: { steps: result.steps.length, whatsapp: user.whatsapp },
 *     startTime: t0,
 *     endTime: Date.now(),
 *   }));
 */
export interface TraceEvent {
    traceId: string;
    name: string;
    input?: unknown;
    output?: unknown;
    metadata?: Record<string, unknown>;
    /** Milliseconds since epoch. */
    startTime: number;
    /** Milliseconds since epoch. */
    endTime: number;
}
export interface Tracer {
    flushTrace(event: TraceEvent): Promise<void> | void;
}
export declare class NoOpTracer implements Tracer {
    flushTrace(_event: TraceEvent): void;
}
export interface LangfuseTracerOptions {
    publicKey: string;
    secretKey: string;
    /** Default `https://cloud.langfuse.com`. */
    host?: string;
    /** Environment tag (e.g. `production` / `staging`). */
    environment?: string;
    /** Injected for tests; defaults to global `fetch`. */
    fetch?: typeof fetch;
}
/**
 * Fire-and-forget POST to Langfuse's ingestion endpoint. Errors are logged
 * and swallowed — a tracing failure must never fail the request. Wrap the
 * call in `ctx.waitUntil(...)` at the caller for zero user-visible latency.
 */
export declare class LangfuseTracer implements Tracer {
    private readonly host;
    private readonly auth;
    private readonly environment;
    private readonly fetchImpl;
    constructor(opts: LangfuseTracerOptions);
    flushTrace(ev: TraceEvent): Promise<void>;
}
//# sourceMappingURL=tracer.d.ts.map