@helicone/helpers/dist/manual_logger/HeliconeManualLogger.d.ts

A Node.js wrapper for some of Helicone's common functionalities

import { IHeliconeManualLogger, HeliconeLogRequest } from "./types";
import { HeliconeLogBuilder } from "./HeliconeLogBuilder";
export { HeliconeLogBuilder };
export declare class HeliconeManualLogger {
    private apiKey;
    private headers;
    private LOGGING_ENDPOINT;
    constructor(opts: IHeliconeManualLogger);
    /**
     * Creates a log builder for more flexible stream handling with error management
     * @param request - The request object to log
     * @param additionalHeaders - Additional headers to send with the request
     * @returns A HeliconeLogBuilder instance
     */
    logBuilder(request: HeliconeLogRequest, additionalHeaders?: Record<string, string>): HeliconeLogBuilder;
    /**
     * Logs a custom request to Helicone
     * @param request - The request object to log
     * @param operation - The operation which will be executed and logged
     * @param additionalHeaders - Additional headers to send with the request
     * @returns The result of the `operation` function
     */
    logRequest<T>(request: HeliconeLogRequest, operation: (resultRecorder: HeliconeResultRecorder) => Promise<T>, additionalHeaders?: Record<string, string>): Promise<T>;
    /**
     * Logs a single stream to Helicone
     * @param request - The request object to log
     * @param stream - The ReadableStream to consume and log
     * @param additionalHeaders - Additional headers to send with the request
     * @returns A Promise that resolves when logging is complete
     */
    logSingleStream(request: HeliconeLogRequest, stream: ReadableStream, additionalHeaders?: Record<string, string>): Promise<void>;
    /**
     * Logs a single request with a response body to Helicone
     * @param request - The request object to log
     * @param body - The response body as a string
     * @param additionalHeaders - Additional headers to send with the request
     * @param latencyMs - The latency of the request in milliseconds
     * @returns A Promise that resolves when logging is complete
     *
     * @example
     * ```typescript
     * helicone.logSingleRequest(request, body, { additionalHeaders: { "Helicone-User-Id": userId }, latencyMs: 1000 });
     * ```
     */
    logSingleRequest(request: HeliconeLogRequest, body: string, options: {
        additionalHeaders?: Record<string, string>;
        latencyMs?: number;
    }): Promise<void>;
    /**
     * Logs a streaming operation to Helicone
     * @param request - The request object to log
     * @param operation - The operation which will be executed and logged, with access to a stream recorder
     * @param additionalHeaders - Additional headers to send with the request
     * @returns The result of the `operation` function
     *
     * @example
     * ```typescript
     * const response = await llmProvider.createChatCompletion({ stream: true, ... });
     * const [stream1, stream2] = response.tee();
     *
     * helicone.logStream(
     *   requestBody,
     *   async (resultRecorder) => {
     *     resultRecorder.attachStream(stream2.toReadableStream());
     *     return stream1;
     *   },
     *   { "Helicone-User-Id": userId }
     * );
     * ```
     */
    logStream<T>(request: HeliconeLogRequest, operation: (resultRecorder: HeliconeStreamResultRecorder) => Promise<T>, additionalHeaders?: Record<string, string>): Promise<T>;
    sendLog(request: HeliconeLogRequest, response: Record<string, any> | string, options: {
        startTime: number;
        endTime: number;
        additionalHeaders?: Record<string, string>;
        timeToFirstToken?: number;
        status?: number;
    }): Promise<void>;
}
/**
 * Recorder for handling and processing streams in Helicone logging
 * Used to capture and process streaming responses from LLM providers
 */
declare class HeliconeStreamResultRecorder {
    private streams;
    firstChunkTimeUnix: number | null;
    constructor();
    /**
     * Attaches a ReadableStream to be processed
     * @param stream - The ReadableStream to attach
     */
    attachStream(stream: ReadableStream): void;
    /**
     * Processes all attached streams and returns their contents as strings
     * @returns Promise resolving to an array of strings containing the content of each stream
     */
    getStreamTexts(): Promise<string[]>;
}
/**
 * Recorder for handling and storing results in Helicone logging
 * Used to capture non-streaming responses from operations
 */
declare class HeliconeResultRecorder {
    private results;
    /**
     * Appends data to the results object
     * @param data - The data to append to the results
     */
    appendResults(data: Record<string, any>): void;
    /**
     * Gets the current results
     * @returns The current results object
     */
    getResults(): Record<string, any>;
}
//# sourceMappingURL=HeliconeManualLogger.d.ts.map