@ai2070/l0/dist/zod/observability.js

L0: The Missing Reliability Substrate for AI

import { z } from "zod4";
import { GuardrailViolationSchema } from "./guardrails";
import { L0StateSchema } from "./l0";
export const FailureTypeSchema = z.enum([
    "network",
    "model",
    "tool",
    "timeout",
    "abort",
    "zero_output",
    "unknown",
]);
export const RecoveryStrategySchema = z.enum([
    "retry",
    "fallback",
    "continue",
    "halt",
]);
export const RecoveryPolicySchema = z.object({
    retryEnabled: z.boolean(),
    fallbackEnabled: z.boolean(),
    maxRetries: z.number(),
    maxFallbacks: z.number(),
    attempt: z.number(),
    fallbackIndex: z.number(),
});
export const EventCategorySchema = z.enum([
    "SESSION",
    "STREAM",
    "ADAPTER",
    "TIMEOUT",
    "NETWORK",
    "ABORT",
    "GUARDRAIL",
    "DRIFT",
    "CHECKPOINT",
    "RESUME",
    "RETRY",
    "FALLBACK",
    "STRUCTURED",
    "CONTINUATION",
    "TOOL",
    "COMPLETION",
]);
export const EventTypeSchema = z.enum([
    "SESSION_START",
    "SESSION_END",
    "SESSION_SUMMARY",
    "ATTEMPT_START",
    "STREAM_INIT",
    "STREAM_READY",
    "ADAPTER_DETECTED",
    "ADAPTER_WRAP_START",
    "ADAPTER_WRAP_END",
    "TIMEOUT_START",
    "TIMEOUT_RESET",
    "TIMEOUT_TRIGGERED",
    "NETWORK_ERROR",
    "NETWORK_RECOVERY",
    "CONNECTION_DROPPED",
    "CONNECTION_RESTORED",
    "ABORT_REQUESTED",
    "ABORT_COMPLETED",
    "GUARDRAIL_PHASE_START",
    "GUARDRAIL_RULE_START",
    "GUARDRAIL_RULE_RESULT",
    "GUARDRAIL_RULE_END",
    "GUARDRAIL_PHASE_END",
    "GUARDRAIL_CALLBACK_START",
    "GUARDRAIL_CALLBACK_END",
    "DRIFT_CHECK_START",
    "DRIFT_CHECK_RESULT",
    "DRIFT_CHECK_END",
    "DRIFT_CHECK_SKIPPED",
    "CHECKPOINT_SAVED",
    "RESUME_START",
    "RETRY_START",
    "RETRY_ATTEMPT",
    "RETRY_END",
    "RETRY_GIVE_UP",
    "RETRY_FN_START",
    "RETRY_FN_RESULT",
    "RETRY_FN_ERROR",
    "FALLBACK_START",
    "FALLBACK_MODEL_SELECTED",
    "FALLBACK_END",
    "STRUCTURED_PARSE_START",
    "STRUCTURED_PARSE_END",
    "STRUCTURED_PARSE_ERROR",
    "STRUCTURED_VALIDATION_START",
    "STRUCTURED_VALIDATION_END",
    "STRUCTURED_VALIDATION_ERROR",
    "STRUCTURED_AUTO_CORRECT_START",
    "STRUCTURED_AUTO_CORRECT_END",
    "CONTINUATION_START",
    "TOOL_REQUESTED",
    "TOOL_START",
    "TOOL_RESULT",
    "TOOL_ERROR",
    "TOOL_COMPLETED",
    "COMPLETE",
    "ERROR",
]);
export const ToolErrorTypeSchema = z.enum([
    "NOT_FOUND",
    "TIMEOUT",
    "EXECUTION_ERROR",
    "VALIDATION_ERROR",
]);
const BaseObservabilityEventSchema = z.object({
    type: EventTypeSchema,
    ts: z.number(),
    streamId: z.string(),
    context: z.record(z.string(), z.unknown()),
});
export const L0ObservabilityEventSchema = BaseObservabilityEventSchema;
export const SessionStartEventSchema = BaseObservabilityEventSchema.extend({
    type: z.literal("SESSION_START"),
    attempt: z.number(),
    isRetry: z.boolean(),
    isFallback: z.boolean(),
});
export const SessionEndEventSchema = BaseObservabilityEventSchema.extend({
    type: z.literal("SESSION_END"),
    durationMs: z.number(),
    success: z.boolean(),
    tokenCount: z.number(),
});
export const SessionSummaryEventSchema = BaseObservabilityEventSchema.extend({
    type: z.literal("SESSION_SUMMARY"),
    tokenCount: z.number(),
    startTs: z.number(),
    endTs: z.number(),
    totalTokens: z.number(),
    totalRetries: z.number(),
    totalFallbacks: z.number(),
    violations: z.number(),
    driftDetected: z.boolean(),
    guardrailViolations: z.number(),
    fallbackDepth: z.number(),
    retryCount: z.number(),
    checkpointsCreated: z.number(),
});
export const AttemptStartEventSchema = BaseObservabilityEventSchema.extend({
    type: z.literal("ATTEMPT_START"),
    attempt: z.number(),
    isRetry: z.boolean(),
    isFallback: z.boolean(),
});
export const StreamInitEventSchema = BaseObservabilityEventSchema.extend({
    type: z.literal("STREAM_INIT"),
});
export const StreamReadyEventSchema = BaseObservabilityEventSchema.extend({
    type: z.literal("STREAM_READY"),
    adapterName: z.string().optional(),
});
export const AdapterDetectedEventSchema = BaseObservabilityEventSchema.extend({
    type: z.literal("ADAPTER_DETECTED"),
    adapterName: z.string(),
    adapter: z.string(),
});
export const AdapterWrapStartEventSchema = BaseObservabilityEventSchema.extend({
    type: z.literal("ADAPTER_WRAP_START"),
    adapterName: z.string(),
});
export const AdapterWrapEndEventSchema = BaseObservabilityEventSchema.extend({
    type: z.literal("ADAPTER_WRAP_END"),
    adapterName: z.string(),
    durationMs: z.number(),
});
export const TimeoutStartEventSchema = BaseObservabilityEventSchema.extend({
    type: z.literal("TIMEOUT_START"),
    timeoutType: z.enum(["initial", "inter"]),
    timeoutMs: z.number(),
});
export const TimeoutResetEventSchema = BaseObservabilityEventSchema.extend({
    type: z.literal("TIMEOUT_RESET"),
    timeoutType: z.enum(["initial", "inter"]),
    tokenIndex: z.number().optional(),
});
export const TimeoutTriggeredEventSchema = BaseObservabilityEventSchema.extend({
    type: z.literal("TIMEOUT_TRIGGERED"),
    timeoutType: z.enum(["initial", "inter"]),
    elapsedMs: z.number(),
});
export const NetworkErrorEventSchema = BaseObservabilityEventSchema.extend({
    type: z.literal("NETWORK_ERROR"),
    error: z.string(),
    errorCode: z.string().optional(),
    code: z.string().optional(),
    category: z.string(),
    retryable: z.boolean(),
});
export const NetworkRecoveryEventSchema = BaseObservabilityEventSchema.extend({
    type: z.literal("NETWORK_RECOVERY"),
    attempt: z.number(),
    attemptCount: z.number(),
    delayMs: z.number(),
    durationMs: z.number(),
});
export const ConnectionDroppedEventSchema = BaseObservabilityEventSchema.extend({
    type: z.literal("CONNECTION_DROPPED"),
    reason: z.string().optional(),
});
export const ConnectionRestoredEventSchema = BaseObservabilityEventSchema.extend({
    type: z.literal("CONNECTION_RESTORED"),
    downtimeMs: z.number(),
});
export const AbortRequestedEventSchema = BaseObservabilityEventSchema.extend({
    type: z.literal("ABORT_REQUESTED"),
    source: z.enum(["user", "timeout", "error"]).optional(),
});
export const AbortCompletedEventSchema = BaseObservabilityEventSchema.extend({
    type: z.literal("ABORT_COMPLETED"),
    tokenCount: z.number(),
    contentLength: z.number(),
    resourcesFreed: z.boolean().optional(),
});
export const GuardrailPhaseStartEventSchema = BaseObservabilityEventSchema.extend({
    type: z.literal("GUARDRAIL_PHASE_START"),
    callbackId: z.string().optional(),
    ruleCount: z.number(),
    tokenCount: z.number(),
    contextSize: z.number().optional(),
});
export const GuardrailRuleStartEventSchema = BaseObservabilityEventSchema.extend({
    type: z.literal("GUARDRAIL_RULE_START"),
    index: z.number(),
    ruleId: z.string(),
    callbackId: z.string().optional(),
});
export const GuardrailRuleResultEventSchema = BaseObservabilityEventSchema.extend({
    type: z.literal("GUARDRAIL_RULE_RESULT"),
    index: z.number(),
    ruleId: z.string(),
    callbackId: z.string().optional(),
    passed: z.boolean(),
    result: z.unknown().optional(),
    violation: GuardrailViolationSchema.optional(),
    rule: z.unknown().optional(),
});
export const GuardrailRuleEndEventSchema = BaseObservabilityEventSchema.extend({
    type: z.literal("GUARDRAIL_RULE_END"),
    index: z.number(),
    ruleId: z.string(),
    callbackId: z.string().optional(),
    durationMs: z.number(),
});
export const GuardrailPhaseEndEventSchema = BaseObservabilityEventSchema.extend({
    type: z.literal("GUARDRAIL_PHASE_END"),
    callbackId: z.string().optional(),
    totalDurationMs: z.number(),
    durationMs: z.number(),
    ruleCount: z.number(),
    violations: z.array(GuardrailViolationSchema),
    shouldRetry: z.boolean(),
    shouldHalt: z.boolean(),
});
export const GuardrailCallbackStartEventSchema = BaseObservabilityEventSchema.extend({
    type: z.literal("GUARDRAIL_CALLBACK_START"),
    callbackId: z.string().optional(),
    callbackType: z.literal("onViolation"),
    index: z.number().optional(),
    ruleId: z.string().optional(),
});
export const GuardrailCallbackEndEventSchema = BaseObservabilityEventSchema.extend({
    type: z.literal("GUARDRAIL_CALLBACK_END"),
    callbackId: z.string().optional(),
    callbackType: z.literal("onViolation"),
    index: z.number().optional(),
    ruleId: z.string().optional(),
    durationMs: z.number(),
    success: z.boolean().optional(),
    error: z.string().optional(),
});
export const DriftCheckStartEventSchema = BaseObservabilityEventSchema.extend({
    type: z.literal("DRIFT_CHECK_START"),
    checkpoint: z.string().optional(),
    tokenCount: z.number(),
    contentLength: z.number(),
    strategy: z.string().optional(),
});
export const DriftCheckResultEventSchema = BaseObservabilityEventSchema.extend({
    type: z.literal("DRIFT_CHECK_RESULT"),
    detected: z.boolean(),
    types: z.array(z.string()),
    confidence: z.number().optional(),
    metrics: z.record(z.string(), z.unknown()).optional(),
    threshold: z.number().optional(),
});
export const DriftCheckEndEventSchema = BaseObservabilityEventSchema.extend({
    type: z.literal("DRIFT_CHECK_END"),
    durationMs: z.number(),
    detected: z.boolean(),
});
export const DriftCheckSkippedEventSchema = BaseObservabilityEventSchema.extend({
    type: z.literal("DRIFT_CHECK_SKIPPED"),
    reason: z.string(),
});
export const CheckpointSavedEventSchema = BaseObservabilityEventSchema.extend({
    type: z.literal("CHECKPOINT_SAVED"),
    checkpoint: z.string(),
    tokenCount: z.number(),
});
export const ResumeStartEventSchema = BaseObservabilityEventSchema.extend({
    type: z.literal("RESUME_START"),
    checkpoint: z.string(),
    stateHash: z.string().optional(),
    tokenCount: z.number(),
});
export const RetryStartEventSchema = BaseObservabilityEventSchema.extend({
    type: z.literal("RETRY_START"),
    attempt: z.number(),
    maxAttempts: z.number(),
    reason: z.string(),
});
export const RetryAttemptEventSchema = BaseObservabilityEventSchema.extend({
    type: z.literal("RETRY_ATTEMPT"),
    index: z.number().optional(),
    attempt: z.number(),
    maxAttempts: z.number(),
    reason: z.string(),
    delayMs: z.number(),
    countsTowardLimit: z.boolean().optional(),
    isNetwork: z.boolean().optional(),
    isModelIssue: z.boolean().optional(),
});
export const RetryEndEventSchema = BaseObservabilityEventSchema.extend({
    type: z.literal("RETRY_END"),
    attempt: z.number(),
    totalAttempts: z.number(),
    success: z.boolean(),
    durationMs: z.number().optional(),
    finalReason: z.string().optional(),
});
export const RetryGiveUpEventSchema = BaseObservabilityEventSchema.extend({
    type: z.literal("RETRY_GIVE_UP"),
    totalAttempts: z.number(),
    reason: z.string(),
    lastError: z.string().optional(),
});
export const RetryFnStartEventSchema = BaseObservabilityEventSchema.extend({
    type: z.literal("RETRY_FN_START"),
    attempt: z.number(),
    category: z.string(),
    defaultShouldRetry: z.boolean(),
});
export const RetryFnResultEventSchema = BaseObservabilityEventSchema.extend({
    type: z.literal("RETRY_FN_RESULT"),
    attempt: z.number(),
    category: z.string(),
    userResult: z.boolean(),
    finalShouldRetry: z.boolean(),
    durationMs: z.number(),
});
export const RetryFnErrorEventSchema = BaseObservabilityEventSchema.extend({
    type: z.literal("RETRY_FN_ERROR"),
    attempt: z.number(),
    category: z.string(),
    error: z.string(),
    finalShouldRetry: z.boolean(),
    durationMs: z.number(),
});
export const FallbackStartEventSchema = BaseObservabilityEventSchema.extend({
    type: z.literal("FALLBACK_START"),
    fromIndex: z.number(),
    toIndex: z.number(),
    reason: z.string(),
});
export const FallbackModelSelectedEventSchema = BaseObservabilityEventSchema.extend({
    type: z.literal("FALLBACK_MODEL_SELECTED"),
    index: z.number(),
});
export const FallbackEndEventSchema = BaseObservabilityEventSchema.extend({
    type: z.literal("FALLBACK_END"),
    finalIndex: z.number(),
    success: z.boolean(),
});
export const StructuredParseStartEventSchema = BaseObservabilityEventSchema.extend({
    type: z.literal("STRUCTURED_PARSE_START"),
    contentLength: z.number(),
});
export const StructuredParseEndEventSchema = BaseObservabilityEventSchema.extend({
    type: z.literal("STRUCTURED_PARSE_END"),
    durationMs: z.number(),
    success: z.boolean(),
});
export const StructuredParseErrorEventSchema = BaseObservabilityEventSchema.extend({
    type: z.literal("STRUCTURED_PARSE_ERROR"),
    error: z.string(),
    contentPreview: z.string().optional(),
});
export const StructuredValidationStartEventSchema = BaseObservabilityEventSchema.extend({
    type: z.literal("STRUCTURED_VALIDATION_START"),
    schemaName: z.string().optional(),
});
export const StructuredValidationEndEventSchema = BaseObservabilityEventSchema.extend({
    type: z.literal("STRUCTURED_VALIDATION_END"),
    durationMs: z.number(),
    valid: z.boolean(),
});
export const StructuredValidationErrorEventSchema = BaseObservabilityEventSchema.extend({
    type: z.literal("STRUCTURED_VALIDATION_ERROR"),
    errors: z.array(z.string()),
});
export const StructuredAutoCorrectStartEventSchema = BaseObservabilityEventSchema.extend({
    type: z.literal("STRUCTURED_AUTO_CORRECT_START"),
    errorCount: z.number(),
});
export const StructuredAutoCorrectEndEventSchema = BaseObservabilityEventSchema.extend({
    type: z.literal("STRUCTURED_AUTO_CORRECT_END"),
    durationMs: z.number(),
    success: z.boolean(),
    correctionsMade: z.number(),
});
export const ContinuationStartEventSchema = BaseObservabilityEventSchema.extend({
    type: z.literal("CONTINUATION_START"),
    checkpoint: z.string(),
    tokenCount: z.number(),
});
export const ToolRequestedEventSchema = BaseObservabilityEventSchema.extend({
    type: z.literal("TOOL_REQUESTED"),
    toolName: z.string(),
    toolCallId: z.string(),
    arguments: z.record(z.string(), z.unknown()),
});
export const ToolStartEventSchema = BaseObservabilityEventSchema.extend({
    type: z.literal("TOOL_START"),
    toolCallId: z.string(),
    toolName: z.string(),
});
export const ToolResultEventSchema = BaseObservabilityEventSchema.extend({
    type: z.literal("TOOL_RESULT"),
    toolCallId: z.string(),
    result: z.unknown(),
    durationMs: z.number(),
});
export const ToolErrorEventSchema = BaseObservabilityEventSchema.extend({
    type: z.literal("TOOL_ERROR"),
    toolCallId: z.string(),
    error: z.string(),
    errorType: ToolErrorTypeSchema,
    durationMs: z.number(),
});
export const ToolCompletedEventSchema = BaseObservabilityEventSchema.extend({
    type: z.literal("TOOL_COMPLETED"),
    toolCallId: z.string(),
    status: z.enum(["success", "error"]),
});
export const CompleteEventSchema = BaseObservabilityEventSchema.extend({
    type: z.literal("COMPLETE"),
    tokenCount: z.number(),
    contentLength: z.number(),
    durationMs: z.number(),
    state: L0StateSchema.optional(),
});
export const ErrorEventSchema = BaseObservabilityEventSchema.extend({
    type: z.literal("ERROR"),
    error: z.string(),
    errorCode: z.string().optional(),
    failureType: FailureTypeSchema,
    recoveryStrategy: RecoveryStrategySchema,
    policy: RecoveryPolicySchema,
});
export const L0EventUnionSchema = z.union([
    SessionStartEventSchema,
    SessionEndEventSchema,
    SessionSummaryEventSchema,
    AttemptStartEventSchema,
    StreamInitEventSchema,
    StreamReadyEventSchema,
    AdapterDetectedEventSchema,
    AdapterWrapStartEventSchema,
    AdapterWrapEndEventSchema,
    TimeoutStartEventSchema,
    TimeoutResetEventSchema,
    TimeoutTriggeredEventSchema,
    NetworkErrorEventSchema,
    NetworkRecoveryEventSchema,
    ConnectionDroppedEventSchema,
    ConnectionRestoredEventSchema,
    AbortRequestedEventSchema,
    AbortCompletedEventSchema,
    GuardrailPhaseStartEventSchema,
    GuardrailRuleStartEventSchema,
    GuardrailRuleResultEventSchema,
    GuardrailRuleEndEventSchema,
    GuardrailPhaseEndEventSchema,
    GuardrailCallbackStartEventSchema,
    GuardrailCallbackEndEventSchema,
    DriftCheckStartEventSchema,
    DriftCheckResultEventSchema,
    DriftCheckEndEventSchema,
    DriftCheckSkippedEventSchema,
    CheckpointSavedEventSchema,
    ResumeStartEventSchema,
    RetryStartEventSchema,
    RetryAttemptEventSchema,
    RetryEndEventSchema,
    RetryGiveUpEventSchema,
    RetryFnStartEventSchema,
    RetryFnResultEventSchema,
    RetryFnErrorEventSchema,
    FallbackStartEventSchema,
    FallbackModelSelectedEventSchema,
    FallbackEndEventSchema,
    StructuredParseStartEventSchema,
    StructuredParseEndEventSchema,
    StructuredParseErrorEventSchema,
    StructuredValidationStartEventSchema,
    StructuredValidationEndEventSchema,
    StructuredValidationErrorEventSchema,
    StructuredAutoCorrectStartEventSchema,
    StructuredAutoCorrectEndEventSchema,
    ContinuationStartEventSchema,
    ToolRequestedEventSchema,
    ToolStartEventSchema,
    ToolResultEventSchema,
    ToolErrorEventSchema,
    ToolCompletedEventSchema,
    CompleteEventSchema,
    ErrorEventSchema,
]);
//# sourceMappingURL=observability.js.map