@ai2070/l0/dist/types/events.d.ts

L0: The Missing Reliability Substrate for AI

import type { GuardrailViolation } from "./guardrails";
import type { BackoffStrategy } from "./retry";
import type { FailureType, RecoveryStrategy, RecoveryPolicy } from "./observability";
export declare const L0RecordedEventTypes: {
    readonly START: "START";
    readonly TOKEN: "TOKEN";
    readonly CHECKPOINT: "CHECKPOINT";
    readonly GUARDRAIL: "GUARDRAIL";
    readonly DRIFT: "DRIFT";
    readonly RETRY: "RETRY";
    readonly FALLBACK: "FALLBACK";
    readonly CONTINUATION: "CONTINUATION";
    readonly COMPLETE: "COMPLETE";
    readonly ERROR: "ERROR";
};
export type L0RecordedEventType = (typeof L0RecordedEventTypes)[keyof typeof L0RecordedEventTypes];
export interface SerializedOptions {
    prompt?: string;
    model?: string;
    retry?: {
        attempts?: number;
        maxRetries?: number;
        baseDelay?: number;
        maxDelay?: number;
        backoff?: BackoffStrategy;
    };
    timeout?: {
        initialToken?: number;
        interToken?: number;
    };
    checkIntervals?: {
        guardrails?: number;
        drift?: number;
        checkpoint?: number;
    };
    continueFromLastKnownGoodToken?: boolean;
    detectDrift?: boolean;
    detectZeroTokens?: boolean;
    fallbackCount?: number;
    guardrailCount?: number;
    metadata?: Record<string, unknown>;
}
export interface SerializedError {
    name: string;
    message: string;
    code?: string;
    stack?: string;
    metadata?: Record<string, unknown>;
}
export interface GuardrailEventResult {
    violations: GuardrailViolation[];
    shouldRetry: boolean;
    shouldHalt: boolean;
}
export interface DriftEventResult {
    detected: boolean;
    types: string[];
    confidence: number;
}
export type L0RecordedEvent = L0StartEvent | L0TokenEvent | L0CheckpointEvent | L0GuardrailEvent | L0DriftEvent | L0RetryEvent | L0FallbackEvent | L0ContinuationEvent | L0CompleteEvent | L0ErrorEvent;
export interface L0StartEvent {
    type: "START";
    ts: number;
    options: SerializedOptions;
}
export interface L0TokenEvent {
    type: "TOKEN";
    ts: number;
    value: string;
    index: number;
}
export interface L0CheckpointEvent {
    type: "CHECKPOINT";
    ts: number;
    at: number;
    content: string;
}
export interface L0GuardrailEvent {
    type: "GUARDRAIL";
    ts: number;
    at: number;
    result: GuardrailEventResult;
}
export interface L0DriftEvent {
    type: "DRIFT";
    ts: number;
    at: number;
    result: DriftEventResult;
}
export interface L0RetryEvent {
    type: "RETRY";
    ts: number;
    reason: string;
    attempt: number;
    countsTowardLimit: boolean;
}
export interface L0FallbackEvent {
    type: "FALLBACK";
    ts: number;
    to: number;
}
export interface L0ContinuationEvent {
    type: "CONTINUATION";
    ts: number;
    checkpoint: string;
    at: number;
}
export interface L0CompleteEvent {
    type: "COMPLETE";
    ts: number;
    content: string;
    tokenCount: number;
}
export interface L0ErrorEvent {
    type: "ERROR";
    ts: number;
    error: SerializedError;
    failureType: FailureType;
    recoveryStrategy: RecoveryStrategy;
    policy: RecoveryPolicy;
}
export interface L0EventEnvelope {
    streamId: string;
    seq: number;
    event: L0RecordedEvent;
}
export interface L0EventStore {
    append(streamId: string, event: L0RecordedEvent): Promise<void>;
    getEvents(streamId: string): Promise<L0EventEnvelope[]>;
    exists(streamId: string): Promise<boolean>;
    getLastEvent(streamId: string): Promise<L0EventEnvelope | null>;
    getEventsAfter(streamId: string, afterSeq: number): Promise<L0EventEnvelope[]>;
    delete(streamId: string): Promise<void>;
    listStreams(): Promise<string[]>;
}
export interface L0Snapshot {
    streamId: string;
    seq: number;
    ts: number;
    content: string;
    tokenCount: number;
    checkpoint: string;
    violations: GuardrailViolation[];
    driftDetected: boolean;
    retryAttempts: number;
    networkRetryCount: number;
    fallbackIndex: number;
}
export interface L0EventStoreWithSnapshots extends L0EventStore {
    saveSnapshot(snapshot: L0Snapshot): Promise<void>;
    getSnapshot(streamId: string): Promise<L0Snapshot | null>;
    getSnapshotBefore(streamId: string, seq: number): Promise<L0Snapshot | null>;
}
export type L0ExecutionMode = "live" | "record" | "replay";
export interface L0ReplayOptions {
    streamId: string;
    eventStore: L0EventStore;
    speed?: number;
    fireCallbacks?: boolean;
    fromSeq?: number;
    toSeq?: number;
}
export interface L0RecordOptions {
    eventStore: L0EventStore;
    streamId?: string;
    saveSnapshots?: boolean;
    snapshotInterval?: number;
}
export declare function serializeError(error: Error): SerializedError;
export declare function deserializeError(stored: SerializedError): Error;
export declare function generateStreamId(): string;
//# sourceMappingURL=events.d.ts.map