@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";
const FailureTypeSchema = z.enum([
  "network",
  "model",
  "tool",
  "timeout",
  "abort",
  "zero_output",
  "unknown"
]);
const RecoveryStrategySchema = z.enum([
  "retry",
  "fallback",
  "continue",
  "halt"
]);
const RecoveryPolicySchema = z.object({
  retryEnabled: z.boolean(),
  fallbackEnabled: z.boolean(),
  maxRetries: z.number(),
  maxFallbacks: z.number(),
  attempt: z.number(),
  fallbackIndex: z.number()
});
const EventCategorySchema = z.enum([
  "SESSION",
  "STREAM",
  "ADAPTER",
  "TIMEOUT",
  "NETWORK",
  "ABORT",
  "GUARDRAIL",
  "DRIFT",
  "CHECKPOINT",
  "RESUME",
  "RETRY",
  "FALLBACK",
  "STRUCTURED",
  "CONTINUATION",
  "TOOL",
  "COMPLETION"
]);
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"
]);
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())
});
const L0ObservabilityEventSchema = BaseObservabilityEventSchema;
const SessionStartEventSchema = BaseObservabilityEventSchema.extend({
  type: z.literal("SESSION_START"),
  attempt: z.number(),
  isRetry: z.boolean(),
  isFallback: z.boolean()
});
const SessionEndEventSchema = BaseObservabilityEventSchema.extend({
  type: z.literal("SESSION_END"),
  durationMs: z.number(),
  success: z.boolean(),
  tokenCount: z.number()
});
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()
});
const AttemptStartEventSchema = BaseObservabilityEventSchema.extend({
  type: z.literal("ATTEMPT_START"),
  attempt: z.number(),
  isRetry: z.boolean(),
  isFallback: z.boolean()
});
const StreamInitEventSchema = BaseObservabilityEventSchema.extend({
  type: z.literal("STREAM_INIT")
});
const StreamReadyEventSchema = BaseObservabilityEventSchema.extend({
  type: z.literal("STREAM_READY"),
  adapterName: z.string().optional()
});
const AdapterDetectedEventSchema = BaseObservabilityEventSchema.extend({
  type: z.literal("ADAPTER_DETECTED"),
  adapterName: z.string(),
  adapter: z.string()
});
const AdapterWrapStartEventSchema = BaseObservabilityEventSchema.extend({
  type: z.literal("ADAPTER_WRAP_START"),
  adapterName: z.string()
});
const AdapterWrapEndEventSchema = BaseObservabilityEventSchema.extend({
  type: z.literal("ADAPTER_WRAP_END"),
  adapterName: z.string(),
  durationMs: z.number()
});
const TimeoutStartEventSchema = BaseObservabilityEventSchema.extend({
  type: z.literal("TIMEOUT_START"),
  timeoutType: z.enum(["initial", "inter"]),
  timeoutMs: z.number()
});
const TimeoutResetEventSchema = BaseObservabilityEventSchema.extend({
  type: z.literal("TIMEOUT_RESET"),
  timeoutType: z.enum(["initial", "inter"]),
  tokenIndex: z.number().optional()
});
const TimeoutTriggeredEventSchema = BaseObservabilityEventSchema.extend({
  type: z.literal("TIMEOUT_TRIGGERED"),
  timeoutType: z.enum(["initial", "inter"]),
  elapsedMs: z.number()
});
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()
});
const NetworkRecoveryEventSchema = BaseObservabilityEventSchema.extend({
  type: z.literal("NETWORK_RECOVERY"),
  attempt: z.number(),
  attemptCount: z.number(),
  delayMs: z.number(),
  durationMs: z.number()
});
const ConnectionDroppedEventSchema = BaseObservabilityEventSchema.extend({
  type: z.literal("CONNECTION_DROPPED"),
  reason: z.string().optional()
});
const ConnectionRestoredEventSchema = BaseObservabilityEventSchema.extend({
  type: z.literal("CONNECTION_RESTORED"),
  downtimeMs: z.number()
});
const AbortRequestedEventSchema = BaseObservabilityEventSchema.extend({
  type: z.literal("ABORT_REQUESTED"),
  source: z.enum(["user", "timeout", "error"]).optional()
});
const AbortCompletedEventSchema = BaseObservabilityEventSchema.extend({
  type: z.literal("ABORT_COMPLETED"),
  tokenCount: z.number(),
  contentLength: z.number(),
  resourcesFreed: z.boolean().optional()
});
const GuardrailPhaseStartEventSchema = BaseObservabilityEventSchema.extend({
  type: z.literal("GUARDRAIL_PHASE_START"),
  callbackId: z.string().optional(),
  ruleCount: z.number(),
  tokenCount: z.number(),
  contextSize: z.number().optional()
});
const GuardrailRuleStartEventSchema = BaseObservabilityEventSchema.extend({
  type: z.literal("GUARDRAIL_RULE_START"),
  index: z.number(),
  ruleId: z.string(),
  callbackId: z.string().optional()
});
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()
});
const GuardrailRuleEndEventSchema = BaseObservabilityEventSchema.extend({
  type: z.literal("GUARDRAIL_RULE_END"),
  index: z.number(),
  ruleId: z.string(),
  callbackId: z.string().optional(),
  durationMs: z.number()
});
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()
});
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()
});
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()
});
const DriftCheckStartEventSchema = BaseObservabilityEventSchema.extend({
  type: z.literal("DRIFT_CHECK_START"),
  checkpoint: z.string().optional(),
  tokenCount: z.number(),
  contentLength: z.number(),
  strategy: z.string().optional()
});
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()
});
const DriftCheckEndEventSchema = BaseObservabilityEventSchema.extend({
  type: z.literal("DRIFT_CHECK_END"),
  durationMs: z.number(),
  detected: z.boolean()
});
const DriftCheckSkippedEventSchema = BaseObservabilityEventSchema.extend({
  type: z.literal("DRIFT_CHECK_SKIPPED"),
  reason: z.string()
});
const CheckpointSavedEventSchema = BaseObservabilityEventSchema.extend({
  type: z.literal("CHECKPOINT_SAVED"),
  checkpoint: z.string(),
  tokenCount: z.number()
});
const ResumeStartEventSchema = BaseObservabilityEventSchema.extend({
  type: z.literal("RESUME_START"),
  checkpoint: z.string(),
  stateHash: z.string().optional(),
  tokenCount: z.number()
});
const RetryStartEventSchema = BaseObservabilityEventSchema.extend({
  type: z.literal("RETRY_START"),
  attempt: z.number(),
  maxAttempts: z.number(),
  reason: z.string()
});
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()
});
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()
});
const RetryGiveUpEventSchema = BaseObservabilityEventSchema.extend({
  type: z.literal("RETRY_GIVE_UP"),
  totalAttempts: z.number(),
  reason: z.string(),
  lastError: z.string().optional()
});
const RetryFnStartEventSchema = BaseObservabilityEventSchema.extend({
  type: z.literal("RETRY_FN_START"),
  attempt: z.number(),
  category: z.string(),
  defaultShouldRetry: z.boolean()
});
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()
});
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()
});
const FallbackStartEventSchema = BaseObservabilityEventSchema.extend({
  type: z.literal("FALLBACK_START"),
  fromIndex: z.number(),
  toIndex: z.number(),
  reason: z.string()
});
const FallbackModelSelectedEventSchema = BaseObservabilityEventSchema.extend({
  type: z.literal("FALLBACK_MODEL_SELECTED"),
  index: z.number()
});
const FallbackEndEventSchema = BaseObservabilityEventSchema.extend({
  type: z.literal("FALLBACK_END"),
  finalIndex: z.number(),
  success: z.boolean()
});
const StructuredParseStartEventSchema = BaseObservabilityEventSchema.extend({
  type: z.literal("STRUCTURED_PARSE_START"),
  contentLength: z.number()
});
const StructuredParseEndEventSchema = BaseObservabilityEventSchema.extend({
  type: z.literal("STRUCTURED_PARSE_END"),
  durationMs: z.number(),
  success: z.boolean()
});
const StructuredParseErrorEventSchema = BaseObservabilityEventSchema.extend({
  type: z.literal("STRUCTURED_PARSE_ERROR"),
  error: z.string(),
  contentPreview: z.string().optional()
});
const StructuredValidationStartEventSchema = BaseObservabilityEventSchema.extend({
  type: z.literal("STRUCTURED_VALIDATION_START"),
  schemaName: z.string().optional()
});
const StructuredValidationEndEventSchema = BaseObservabilityEventSchema.extend({
  type: z.literal("STRUCTURED_VALIDATION_END"),
  durationMs: z.number(),
  valid: z.boolean()
});
const StructuredValidationErrorEventSchema = BaseObservabilityEventSchema.extend({
  type: z.literal("STRUCTURED_VALIDATION_ERROR"),
  errors: z.array(z.string())
});
const StructuredAutoCorrectStartEventSchema = BaseObservabilityEventSchema.extend({
  type: z.literal("STRUCTURED_AUTO_CORRECT_START"),
  errorCount: z.number()
});
const StructuredAutoCorrectEndEventSchema = BaseObservabilityEventSchema.extend({
  type: z.literal("STRUCTURED_AUTO_CORRECT_END"),
  durationMs: z.number(),
  success: z.boolean(),
  correctionsMade: z.number()
});
const ContinuationStartEventSchema = BaseObservabilityEventSchema.extend({
  type: z.literal("CONTINUATION_START"),
  checkpoint: z.string(),
  tokenCount: z.number()
});
const ToolRequestedEventSchema = BaseObservabilityEventSchema.extend({
  type: z.literal("TOOL_REQUESTED"),
  toolName: z.string(),
  toolCallId: z.string(),
  arguments: z.record(z.string(), z.unknown())
});
const ToolStartEventSchema = BaseObservabilityEventSchema.extend({
  type: z.literal("TOOL_START"),
  toolCallId: z.string(),
  toolName: z.string()
});
const ToolResultEventSchema = BaseObservabilityEventSchema.extend({
  type: z.literal("TOOL_RESULT"),
  toolCallId: z.string(),
  result: z.unknown(),
  durationMs: z.number()
});
const ToolErrorEventSchema = BaseObservabilityEventSchema.extend({
  type: z.literal("TOOL_ERROR"),
  toolCallId: z.string(),
  error: z.string(),
  errorType: ToolErrorTypeSchema,
  durationMs: z.number()
});
const ToolCompletedEventSchema = BaseObservabilityEventSchema.extend({
  type: z.literal("TOOL_COMPLETED"),
  toolCallId: z.string(),
  status: z.enum(["success", "error"])
});
const CompleteEventSchema = BaseObservabilityEventSchema.extend({
  type: z.literal("COMPLETE"),
  tokenCount: z.number(),
  contentLength: z.number(),
  durationMs: z.number(),
  state: L0StateSchema.optional()
});
const ErrorEventSchema = BaseObservabilityEventSchema.extend({
  type: z.literal("ERROR"),
  error: z.string(),
  errorCode: z.string().optional(),
  failureType: FailureTypeSchema,
  recoveryStrategy: RecoveryStrategySchema,
  policy: RecoveryPolicySchema
});
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
]);
export {
  AbortCompletedEventSchema,
  AbortRequestedEventSchema,
  AdapterDetectedEventSchema,
  AdapterWrapEndEventSchema,
  AdapterWrapStartEventSchema,
  AttemptStartEventSchema,
  CheckpointSavedEventSchema,
  CompleteEventSchema,
  ConnectionDroppedEventSchema,
  ConnectionRestoredEventSchema,
  ContinuationStartEventSchema,
  DriftCheckEndEventSchema,
  DriftCheckResultEventSchema,
  DriftCheckSkippedEventSchema,
  DriftCheckStartEventSchema,
  ErrorEventSchema,
  EventCategorySchema,
  EventTypeSchema,
  FailureTypeSchema,
  FallbackEndEventSchema,
  FallbackModelSelectedEventSchema,
  FallbackStartEventSchema,
  GuardrailCallbackEndEventSchema,
  GuardrailCallbackStartEventSchema,
  GuardrailPhaseEndEventSchema,
  GuardrailPhaseStartEventSchema,
  GuardrailRuleEndEventSchema,
  GuardrailRuleResultEventSchema,
  GuardrailRuleStartEventSchema,
  L0EventUnionSchema,
  L0ObservabilityEventSchema,
  NetworkErrorEventSchema,
  NetworkRecoveryEventSchema,
  RecoveryPolicySchema,
  RecoveryStrategySchema,
  ResumeStartEventSchema,
  RetryAttemptEventSchema,
  RetryEndEventSchema,
  RetryFnErrorEventSchema,
  RetryFnResultEventSchema,
  RetryFnStartEventSchema,
  RetryGiveUpEventSchema,
  RetryStartEventSchema,
  SessionEndEventSchema,
  SessionStartEventSchema,
  SessionSummaryEventSchema,
  StreamInitEventSchema,
  StreamReadyEventSchema,
  StructuredAutoCorrectEndEventSchema,
  StructuredAutoCorrectStartEventSchema,
  StructuredParseEndEventSchema,
  StructuredParseErrorEventSchema,
  StructuredParseStartEventSchema,
  StructuredValidationEndEventSchema,
  StructuredValidationErrorEventSchema,
  StructuredValidationStartEventSchema,
  TimeoutResetEventSchema,
  TimeoutStartEventSchema,
  TimeoutTriggeredEventSchema,
  ToolCompletedEventSchema,
  ToolErrorEventSchema,
  ToolErrorTypeSchema,
  ToolRequestedEventSchema,
  ToolResultEventSchema,
  ToolStartEventSchema
};
//# sourceMappingURL=observability.js.map