@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";
export const ConsensusStrategySchema = z.enum([
    "majority",
    "unanimous",
    "weighted",
    "best",
]);
export const ConflictResolutionSchema = z.enum([
    "vote",
    "merge",
    "fail",
    "best",
]);
export const AgreementTypeSchema = z.enum([
    "exact",
    "similar",
    "structural",
    "semantic",
]);
export const DisagreementSeveritySchema = z.enum(["minor", "moderate", "major", "critical"]);
export const AgreementSchema = z.object({
    content: z.any(),
    path: z.string().optional(),
    count: z.number(),
    ratio: z.number(),
    indices: z.array(z.number()),
    type: AgreementTypeSchema,
});
export 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(),
});
export 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(),
});
export 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(),
});
export const FieldConsensusSchema = z.object({
    fields: z.record(z.string(), FieldAgreementSchema),
    overallAgreement: z.number(),
    agreedFields: z.array(z.string()),
    disagreedFields: z.array(z.string()),
});
export 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(),
});
export 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(),
});
export 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(),
});
export const TextConsensusOptionsSchema = z.object({
    threshold: z.number(),
    strategy: ConsensusStrategySchema,
    resolveConflicts: ConflictResolutionSchema,
    weights: z.array(z.number()),
});
export const StructuredConsensusOptionsSchema = z.object({
    schema: z.any(),
    strategy: ConsensusStrategySchema,
    resolveConflicts: ConflictResolutionSchema,
    weights: z.array(z.number()),
    minimumAgreement: z.number(),
});
export const ConsensusPresetSchema = z.object({
    name: z.string(),
    strategy: ConsensusStrategySchema,
    threshold: z.number(),
    resolveConflicts: ConflictResolutionSchema,
    minimumAgreement: z.number(),
});
//# sourceMappingURL=consensus.js.map