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

L0: The Missing Reliability Substrate for AI

import { z } from "zod4";
import { L0ResultSchema } from "./l0";
import { StructuredResultSchema } from "./structured";
const ConsensusStrategySchema = z.enum([
  "majority",
  "unanimous",
  "weighted",
  "best"
]);
const ConflictResolutionSchema = z.enum([
  "vote",
  "merge",
  "fail",
  "best"
]);
const AgreementTypeSchema = z.enum([
  "exact",
  "similar",
  "structural",
  "semantic"
]);
const DisagreementSeveritySchema = z.enum(["minor", "moderate", "major", "critical"]);
const AgreementSchema = z.object({
  content: z.any(),
  path: z.string().optional(),
  count: z.number(),
  ratio: z.number(),
  indices: z.array(z.number()),
  type: AgreementTypeSchema
});
const DisagreementSchema = z.object({
  path: z.string().optional(),
  values: z.array(
    z.object({
      value: z.any(),
      count: z.number(),
      indices: z.array(z.number())
    })
  ),
  severity: DisagreementSeveritySchema,
  resolution: z.string().optional(),
  resolutionConfidence: z.number().optional()
});
const ConsensusAnalysisSchema = z.object({
  totalOutputs: z.number(),
  successfulOutputs: z.number(),
  failedOutputs: z.number(),
  identicalOutputs: z.number(),
  similarityMatrix: z.array(z.array(z.number())),
  averageSimilarity: z.number(),
  minSimilarity: z.number(),
  maxSimilarity: z.number(),
  totalAgreements: z.number(),
  totalDisagreements: z.number(),
  strategy: ConsensusStrategySchema,
  conflictResolution: ConflictResolutionSchema,
  duration: z.number()
});
const FieldAgreementSchema = z.object({
  path: z.string(),
  value: z.any(),
  agreement: z.number(),
  votes: z.record(z.string(), z.number()),
  values: z.array(z.any()),
  unanimous: z.boolean(),
  confidence: z.number()
});
const FieldConsensusSchema = z.object({
  fields: z.record(z.string(), FieldAgreementSchema),
  overallAgreement: z.number(),
  agreedFields: z.array(z.string()),
  disagreedFields: z.array(z.string())
});
const ConsensusOutputSchema = z.object({
  index: z.number(),
  text: z.string(),
  data: z.any().optional(),
  l0Result: L0ResultSchema.optional(),
  structuredResult: StructuredResultSchema.optional(),
  status: z.enum(["success", "error"]),
  error: z.instanceof(Error).optional(),
  duration: z.number(),
  weight: z.number(),
  similarities: z.array(z.number()).optional()
});
const ConsensusResultSchema = z.object({
  consensus: z.any(),
  confidence: z.number(),
  outputs: z.array(ConsensusOutputSchema),
  agreements: z.array(AgreementSchema),
  disagreements: z.array(DisagreementSchema),
  analysis: ConsensusAnalysisSchema,
  type: z.enum(["text", "structured"]),
  fieldConsensus: FieldConsensusSchema.optional(),
  status: z.enum(["success", "partial", "failed"]),
  error: z.instanceof(Error).optional(),
  metadata: z.record(z.string(), z.any()).optional()
});
const ConsensusOptionsSchema = z.object({
  streams: z.array(z.function()),
  schema: z.any().optional(),
  strategy: ConsensusStrategySchema.optional(),
  threshold: z.number().optional(),
  resolveConflicts: ConflictResolutionSchema.optional(),
  weights: z.array(z.number()).optional(),
  minimumAgreement: z.number().optional(),
  timeout: z.number().optional(),
  signal: z.instanceof(AbortSignal).optional(),
  detectZeroTokens: z.boolean().optional(),
  monitoring: z.object({
    enabled: z.boolean().optional(),
    metadata: z.record(z.string(), z.any()).optional()
  }).optional(),
  onComplete: z.function().optional(),
  onConsensus: z.function().optional(),
  metadata: z.record(z.string(), z.any()).optional()
});
const TextConsensusOptionsSchema = z.object({
  threshold: z.number(),
  strategy: ConsensusStrategySchema,
  resolveConflicts: ConflictResolutionSchema,
  weights: z.array(z.number())
});
const StructuredConsensusOptionsSchema = z.object({
  schema: z.any(),
  strategy: ConsensusStrategySchema,
  resolveConflicts: ConflictResolutionSchema,
  weights: z.array(z.number()),
  minimumAgreement: z.number()
});
const ConsensusPresetSchema = z.object({
  name: z.string(),
  strategy: ConsensusStrategySchema,
  threshold: z.number(),
  resolveConflicts: ConflictResolutionSchema,
  minimumAgreement: z.number()
});
export {
  AgreementSchema,
  AgreementTypeSchema,
  ConflictResolutionSchema,
  ConsensusAnalysisSchema,
  ConsensusOptionsSchema,
  ConsensusOutputSchema,
  ConsensusPresetSchema,
  ConsensusResultSchema,
  ConsensusStrategySchema,
  DisagreementSchema,
  DisagreementSeveritySchema,
  FieldAgreementSchema,
  FieldConsensusSchema,
  StructuredConsensusOptionsSchema,
  TextConsensusOptionsSchema
};
//# sourceMappingURL=consensus.js.map