@defai.digital/contracts 13.0.3

package/dist/discussion/v1/schema.d.ts

@@ -0,0 +1,1186 @@
+/**
+ * Discussion Domain Contracts v1
+ *
+ * Zod schemas for multi-model discussions enabling Claude, GLM, Qwen,
+ * Gemini, Codex, and Grok to collaborate on complex problems.
+ *
+ * @module @defai.digital/contracts/discussion/v1
+ */
+import { z } from 'zod';
+/** Maximum number of providers in a discussion */
+export declare const MAX_PROVIDERS = 6;
+/** Minimum number of providers in a discussion */
+export declare const MIN_PROVIDERS = 2;
+/** Maximum discussion rounds */
+export declare const MAX_ROUNDS = 10;
+/** Default discussion rounds */
+export declare const DEFAULT_ROUNDS = 2;
+/** Default provider timeout in ms */
+export declare const DEFAULT_PROVIDER_TIMEOUT = 60000;
+/** Maximum provider timeout in ms */
+export declare const MAX_PROVIDER_TIMEOUT = 300000;
+/** Default providers for discussions */
+export declare const DEFAULT_PROVIDERS: readonly ["claude", "glm", "qwen", "gemini"];
+/**
+ * Discussion patterns supported by the system
+ *
+ * Invariants:
+ * - INV-DISC-001: Pattern determines execution flow
+ * - INV-DISC-002: All patterns produce a final synthesis
+ */
+export declare const DiscussionPatternSchema: z.ZodEnum<["round-robin", "debate", "critique", "voting", "synthesis"]>;
+export type DiscussionPattern = z.infer<typeof DiscussionPatternSchema>;
+/** Pattern descriptions for documentation/help */
+export declare const PATTERN_DESCRIPTIONS: Record<DiscussionPattern, string>;
+/**
+ * Consensus method for combining model outputs
+ */
+export declare const ConsensusMethodSchema: z.ZodEnum<["synthesis", "voting", "moderator", "unanimous", "majority"]>;
+export type ConsensusMethod = z.infer<typeof ConsensusMethodSchema>;
+/**
+ * Consensus configuration
+ *
+ * Invariants:
+ * - INV-DISC-003: Moderator/synthesizer required when method needs it
+ * - INV-DISC-004: Threshold must be 0-1 for voting methods
+ */
+export declare const ConsensusConfigSchema: z.ZodEffects<z.ZodObject<{
+    /** How to reach consensus */
+    method: z.ZodDefault<z.ZodEnum<["synthesis", "voting", "moderator", "unanimous", "majority"]>>;
+    /** Provider to synthesize/moderate (required for synthesis/moderator) */
+    synthesizer: z.ZodOptional<z.ZodString>;
+    /** Confidence threshold for voting (0-1) */
+    threshold: z.ZodDefault<z.ZodNumber>;
+    /** Whether to include dissenting opinions in output */
+    includeDissent: z.ZodDefault<z.ZodBoolean>;
+    /** Custom synthesis prompt */
+    synthesisPrompt: z.ZodOptional<z.ZodString>;
+}, "strip", z.ZodTypeAny, {
+    method: "voting" | "synthesis" | "moderator" | "unanimous" | "majority";
+    threshold: number;
+    includeDissent: boolean;
+    synthesizer?: string | undefined;
+    synthesisPrompt?: string | undefined;
+}, {
+    method?: "voting" | "synthesis" | "moderator" | "unanimous" | "majority" | undefined;
+    threshold?: number | undefined;
+    synthesizer?: string | undefined;
+    includeDissent?: boolean | undefined;
+    synthesisPrompt?: string | undefined;
+}>, {
+    method: "voting" | "synthesis" | "moderator" | "unanimous" | "majority";
+    threshold: number;
+    includeDissent: boolean;
+    synthesizer?: string | undefined;
+    synthesisPrompt?: string | undefined;
+}, {
+    method?: "voting" | "synthesis" | "moderator" | "unanimous" | "majority" | undefined;
+    threshold?: number | undefined;
+    synthesizer?: string | undefined;
+    includeDissent?: boolean | undefined;
+    synthesisPrompt?: string | undefined;
+}>;
+export type ConsensusConfig = z.infer<typeof ConsensusConfigSchema>;
+/**
+ * Role assignment for debate pattern
+ */
+export declare const DebateRoleSchema: z.ZodEnum<["proponent", "opponent", "judge", "moderator", "neutral"]>;
+export type DebateRole = z.infer<typeof DebateRoleSchema>;
+/**
+ * Provider role assignment
+ */
+export declare const RoleAssignmentSchema: z.ZodRecord<z.ZodString, z.ZodEnum<["proponent", "opponent", "judge", "moderator", "neutral"]>>;
+export type RoleAssignment = z.infer<typeof RoleAssignmentSchema>;
+/**
+ * Provider capability areas
+ */
+export declare const ProviderCapabilitySchema: z.ZodEnum<["reasoning", "coding", "agentic", "research", "writing", "math", "ocr", "translation", "multilingual", "realtime", "tool-use", "long-context"]>;
+export type ProviderCapability = z.infer<typeof ProviderCapabilitySchema>;
+/**
+ * Provider strength mapping (for routing decisions)
+ */
+export declare const PROVIDER_STRENGTHS: Record<string, ProviderCapability[]>;
+/**
+ * Configuration for a discuss workflow step
+ *
+ * Invariants:
+ * - INV-DISC-005: At least 2 providers required
+ * - INV-DISC-006: Max 6 providers per discussion
+ * - INV-DISC-007: Rounds between 1-10
+ * - INV-DISC-008: Debate pattern requires role assignments
+ */
+export declare const DiscussStepConfigSchema: z.ZodEffects<z.ZodEffects<z.ZodObject<{
+    /** Discussion pattern to use */
+    pattern: z.ZodDefault<z.ZodEnum<["round-robin", "debate", "critique", "voting", "synthesis"]>>;
+    /** Number of discussion rounds */
+    rounds: z.ZodDefault<z.ZodNumber>;
+    /** Providers to participate in discussion */
+    providers: z.ZodArray<z.ZodString, "many">;
+    /** Main discussion prompt/topic */
+    prompt: z.ZodString;
+    /** Provider-specific prompt overrides */
+    providerPrompts: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodString>>;
+    /** Role assignments (required for debate pattern) */
+    roles: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodEnum<["proponent", "opponent", "judge", "moderator", "neutral"]>>>;
+    /** Consensus configuration */
+    consensus: z.ZodDefault<z.ZodEffects<z.ZodObject<{
+        /** How to reach consensus */
+        method: z.ZodDefault<z.ZodEnum<["synthesis", "voting", "moderator", "unanimous", "majority"]>>;
+        /** Provider to synthesize/moderate (required for synthesis/moderator) */
+        synthesizer: z.ZodOptional<z.ZodString>;
+        /** Confidence threshold for voting (0-1) */
+        threshold: z.ZodDefault<z.ZodNumber>;
+        /** Whether to include dissenting opinions in output */
+        includeDissent: z.ZodDefault<z.ZodBoolean>;
+        /** Custom synthesis prompt */
+        synthesisPrompt: z.ZodOptional<z.ZodString>;
+    }, "strip", z.ZodTypeAny, {
+        method: "voting" | "synthesis" | "moderator" | "unanimous" | "majority";
+        threshold: number;
+        includeDissent: boolean;
+        synthesizer?: string | undefined;
+        synthesisPrompt?: string | undefined;
+    }, {
+        method?: "voting" | "synthesis" | "moderator" | "unanimous" | "majority" | undefined;
+        threshold?: number | undefined;
+        synthesizer?: string | undefined;
+        includeDissent?: boolean | undefined;
+        synthesisPrompt?: string | undefined;
+    }>, {
+        method: "voting" | "synthesis" | "moderator" | "unanimous" | "majority";
+        threshold: number;
+        includeDissent: boolean;
+        synthesizer?: string | undefined;
+        synthesisPrompt?: string | undefined;
+    }, {
+        method?: "voting" | "synthesis" | "moderator" | "unanimous" | "majority" | undefined;
+        threshold?: number | undefined;
+        synthesizer?: string | undefined;
+        includeDissent?: boolean | undefined;
+        synthesisPrompt?: string | undefined;
+    }>>;
+    /** Timeout per provider response in ms */
+    providerTimeout: z.ZodDefault<z.ZodNumber>;
+    /** Whether to continue if a provider fails */
+    continueOnProviderFailure: z.ZodDefault<z.ZodBoolean>;
+    /** Minimum providers required to succeed */
+    minProviders: z.ZodDefault<z.ZodNumber>;
+    /** Temperature for responses (0-2) */
+    temperature: z.ZodDefault<z.ZodNumber>;
+    /** Enable verbose output with all perspectives */
+    verbose: z.ZodDefault<z.ZodBoolean>;
+    /** Additional context for all providers */
+    context: z.ZodOptional<z.ZodString>;
+}, "strip", z.ZodTypeAny, {
+    prompt: string;
+    pattern: "round-robin" | "debate" | "critique" | "voting" | "synthesis";
+    providers: string[];
+    rounds: number;
+    temperature: number;
+    verbose: boolean;
+    consensus: {
+        method: "voting" | "synthesis" | "moderator" | "unanimous" | "majority";
+        threshold: number;
+        includeDissent: boolean;
+        synthesizer?: string | undefined;
+        synthesisPrompt?: string | undefined;
+    };
+    providerTimeout: number;
+    continueOnProviderFailure: boolean;
+    minProviders: number;
+    context?: string | undefined;
+    providerPrompts?: Record<string, string> | undefined;
+    roles?: Record<string, "moderator" | "proponent" | "opponent" | "judge" | "neutral"> | undefined;
+}, {
+    prompt: string;
+    providers: string[];
+    context?: string | undefined;
+    pattern?: "round-robin" | "debate" | "critique" | "voting" | "synthesis" | undefined;
+    rounds?: number | undefined;
+    temperature?: number | undefined;
+    verbose?: boolean | undefined;
+    providerPrompts?: Record<string, string> | undefined;
+    roles?: Record<string, "moderator" | "proponent" | "opponent" | "judge" | "neutral"> | undefined;
+    consensus?: {
+        method?: "voting" | "synthesis" | "moderator" | "unanimous" | "majority" | undefined;
+        threshold?: number | undefined;
+        synthesizer?: string | undefined;
+        includeDissent?: boolean | undefined;
+        synthesisPrompt?: string | undefined;
+    } | undefined;
+    providerTimeout?: number | undefined;
+    continueOnProviderFailure?: boolean | undefined;
+    minProviders?: number | undefined;
+}>, {
+    prompt: string;
+    pattern: "round-robin" | "debate" | "critique" | "voting" | "synthesis";
+    providers: string[];
+    rounds: number;
+    temperature: number;
+    verbose: boolean;
+    consensus: {
+        method: "voting" | "synthesis" | "moderator" | "unanimous" | "majority";
+        threshold: number;
+        includeDissent: boolean;
+        synthesizer?: string | undefined;
+        synthesisPrompt?: string | undefined;
+    };
+    providerTimeout: number;
+    continueOnProviderFailure: boolean;
+    minProviders: number;
+    context?: string | undefined;
+    providerPrompts?: Record<string, string> | undefined;
+    roles?: Record<string, "moderator" | "proponent" | "opponent" | "judge" | "neutral"> | undefined;
+}, {
+    prompt: string;
+    providers: string[];
+    context?: string | undefined;
+    pattern?: "round-robin" | "debate" | "critique" | "voting" | "synthesis" | undefined;
+    rounds?: number | undefined;
+    temperature?: number | undefined;
+    verbose?: boolean | undefined;
+    providerPrompts?: Record<string, string> | undefined;
+    roles?: Record<string, "moderator" | "proponent" | "opponent" | "judge" | "neutral"> | undefined;
+    consensus?: {
+        method?: "voting" | "synthesis" | "moderator" | "unanimous" | "majority" | undefined;
+        threshold?: number | undefined;
+        synthesizer?: string | undefined;
+        includeDissent?: boolean | undefined;
+        synthesisPrompt?: string | undefined;
+    } | undefined;
+    providerTimeout?: number | undefined;
+    continueOnProviderFailure?: boolean | undefined;
+    minProviders?: number | undefined;
+}>, {
+    prompt: string;
+    pattern: "round-robin" | "debate" | "critique" | "voting" | "synthesis";
+    providers: string[];
+    rounds: number;
+    temperature: number;
+    verbose: boolean;
+    consensus: {
+        method: "voting" | "synthesis" | "moderator" | "unanimous" | "majority";
+        threshold: number;
+        includeDissent: boolean;
+        synthesizer?: string | undefined;
+        synthesisPrompt?: string | undefined;
+    };
+    providerTimeout: number;
+    continueOnProviderFailure: boolean;
+    minProviders: number;
+    context?: string | undefined;
+    providerPrompts?: Record<string, string> | undefined;
+    roles?: Record<string, "moderator" | "proponent" | "opponent" | "judge" | "neutral"> | undefined;
+}, {
+    prompt: string;
+    providers: string[];
+    context?: string | undefined;
+    pattern?: "round-robin" | "debate" | "critique" | "voting" | "synthesis" | undefined;
+    rounds?: number | undefined;
+    temperature?: number | undefined;
+    verbose?: boolean | undefined;
+    providerPrompts?: Record<string, string> | undefined;
+    roles?: Record<string, "moderator" | "proponent" | "opponent" | "judge" | "neutral"> | undefined;
+    consensus?: {
+        method?: "voting" | "synthesis" | "moderator" | "unanimous" | "majority" | undefined;
+        threshold?: number | undefined;
+        synthesizer?: string | undefined;
+        includeDissent?: boolean | undefined;
+        synthesisPrompt?: string | undefined;
+    } | undefined;
+    providerTimeout?: number | undefined;
+    continueOnProviderFailure?: boolean | undefined;
+    minProviders?: number | undefined;
+}>;
+export type DiscussStepConfig = z.infer<typeof DiscussStepConfigSchema>;
+/**
+ * Single provider's response in a discussion
+ * Named DiscussionProviderResponseSchema to avoid conflict with provider/v1 ProviderResponseSchema
+ */
+export declare const DiscussionProviderResponseSchema: z.ZodObject<{
+    /** Provider that generated this response */
+    provider: z.ZodString;
+    /** Response content */
+    content: z.ZodString;
+    /** Round number (1-indexed) */
+    round: z.ZodNumber;
+    /** Role in discussion (if applicable) */
+    role: z.ZodOptional<z.ZodEnum<["proponent", "opponent", "judge", "moderator", "neutral"]>>;
+    /** Confidence score (0-1) for voting */
+    confidence: z.ZodOptional<z.ZodNumber>;
+    /** Vote choice (for voting pattern) */
+    vote: z.ZodOptional<z.ZodString>;
+    /** Response timestamp */
+    timestamp: z.ZodString;
+    /** Duration in ms */
+    durationMs: z.ZodNumber;
+    /** Token count (if available) */
+    tokenCount: z.ZodOptional<z.ZodNumber>;
+    /** Whether response was truncated */
+    truncated: z.ZodOptional<z.ZodBoolean>;
+    /** Error if response failed */
+    error: z.ZodOptional<z.ZodString>;
+}, "strip", z.ZodTypeAny, {
+    timestamp: string;
+    durationMs: number;
+    content: string;
+    provider: string;
+    round: number;
+    error?: string | undefined;
+    role?: "moderator" | "proponent" | "opponent" | "judge" | "neutral" | undefined;
+    tokenCount?: number | undefined;
+    truncated?: boolean | undefined;
+    confidence?: number | undefined;
+    vote?: string | undefined;
+}, {
+    timestamp: string;
+    durationMs: number;
+    content: string;
+    provider: string;
+    round: number;
+    error?: string | undefined;
+    role?: "moderator" | "proponent" | "opponent" | "judge" | "neutral" | undefined;
+    tokenCount?: number | undefined;
+    truncated?: boolean | undefined;
+    confidence?: number | undefined;
+    vote?: string | undefined;
+}>;
+export type DiscussionProviderResponse = z.infer<typeof DiscussionProviderResponseSchema>;
+/**
+ * Discussion round containing all provider responses
+ */
+export declare const DiscussionRoundSchema: z.ZodObject<{
+    /** Round number (1-indexed) */
+    roundNumber: z.ZodNumber;
+    /** Responses from each provider */
+    responses: z.ZodArray<z.ZodObject<{
+        /** Provider that generated this response */
+        provider: z.ZodString;
+        /** Response content */
+        content: z.ZodString;
+        /** Round number (1-indexed) */
+        round: z.ZodNumber;
+        /** Role in discussion (if applicable) */
+        role: z.ZodOptional<z.ZodEnum<["proponent", "opponent", "judge", "moderator", "neutral"]>>;
+        /** Confidence score (0-1) for voting */
+        confidence: z.ZodOptional<z.ZodNumber>;
+        /** Vote choice (for voting pattern) */
+        vote: z.ZodOptional<z.ZodString>;
+        /** Response timestamp */
+        timestamp: z.ZodString;
+        /** Duration in ms */
+        durationMs: z.ZodNumber;
+        /** Token count (if available) */
+        tokenCount: z.ZodOptional<z.ZodNumber>;
+        /** Whether response was truncated */
+        truncated: z.ZodOptional<z.ZodBoolean>;
+        /** Error if response failed */
+        error: z.ZodOptional<z.ZodString>;
+    }, "strip", z.ZodTypeAny, {
+        timestamp: string;
+        durationMs: number;
+        content: string;
+        provider: string;
+        round: number;
+        error?: string | undefined;
+        role?: "moderator" | "proponent" | "opponent" | "judge" | "neutral" | undefined;
+        tokenCount?: number | undefined;
+        truncated?: boolean | undefined;
+        confidence?: number | undefined;
+        vote?: string | undefined;
+    }, {
+        timestamp: string;
+        durationMs: number;
+        content: string;
+        provider: string;
+        round: number;
+        error?: string | undefined;
+        role?: "moderator" | "proponent" | "opponent" | "judge" | "neutral" | undefined;
+        tokenCount?: number | undefined;
+        truncated?: boolean | undefined;
+        confidence?: number | undefined;
+        vote?: string | undefined;
+    }>, "many">;
+    /** Round summary (if generated) */
+    summary: z.ZodOptional<z.ZodString>;
+    /** Round duration in ms */
+    durationMs: z.ZodNumber;
+}, "strip", z.ZodTypeAny, {
+    durationMs: number;
+    roundNumber: number;
+    responses: {
+        timestamp: string;
+        durationMs: number;
+        content: string;
+        provider: string;
+        round: number;
+        error?: string | undefined;
+        role?: "moderator" | "proponent" | "opponent" | "judge" | "neutral" | undefined;
+        tokenCount?: number | undefined;
+        truncated?: boolean | undefined;
+        confidence?: number | undefined;
+        vote?: string | undefined;
+    }[];
+    summary?: string | undefined;
+}, {
+    durationMs: number;
+    roundNumber: number;
+    responses: {
+        timestamp: string;
+        durationMs: number;
+        content: string;
+        provider: string;
+        round: number;
+        error?: string | undefined;
+        role?: "moderator" | "proponent" | "opponent" | "judge" | "neutral" | undefined;
+        tokenCount?: number | undefined;
+        truncated?: boolean | undefined;
+        confidence?: number | undefined;
+        vote?: string | undefined;
+    }[];
+    summary?: string | undefined;
+}>;
+export type DiscussionRound = z.infer<typeof DiscussionRoundSchema>;
+/**
+ * Vote record from a single provider
+ */
+export declare const VoteRecordSchema: z.ZodObject<{
+    /** Provider that cast the vote */
+    provider: z.ZodString;
+    /** Selected option */
+    choice: z.ZodString;
+    /** Confidence in the vote (0-1) */
+    confidence: z.ZodNumber;
+    /** Reasoning for the vote */
+    reasoning: z.ZodOptional<z.ZodString>;
+}, "strip", z.ZodTypeAny, {
+    provider: string;
+    confidence: number;
+    choice: string;
+    reasoning?: string | undefined;
+}, {
+    provider: string;
+    confidence: number;
+    choice: string;
+    reasoning?: string | undefined;
+}>;
+export type VoteRecord = z.infer<typeof VoteRecordSchema>;
+/**
+ * Voting results summary
+ */
+export declare const VotingResultsSchema: z.ZodObject<{
+    /** Winning option */
+    winner: z.ZodString;
+    /** Raw vote counts per option */
+    votes: z.ZodRecord<z.ZodString, z.ZodNumber>;
+    /** Confidence-weighted vote counts */
+    weightedVotes: z.ZodRecord<z.ZodString, z.ZodNumber>;
+    /** Individual vote records */
+    voteRecords: z.ZodArray<z.ZodObject<{
+        /** Provider that cast the vote */
+        provider: z.ZodString;
+        /** Selected option */
+        choice: z.ZodString;
+        /** Confidence in the vote (0-1) */
+        confidence: z.ZodNumber;
+        /** Reasoning for the vote */
+        reasoning: z.ZodOptional<z.ZodString>;
+    }, "strip", z.ZodTypeAny, {
+        provider: string;
+        confidence: number;
+        choice: string;
+        reasoning?: string | undefined;
+    }, {
+        provider: string;
+        confidence: number;
+        choice: string;
+        reasoning?: string | undefined;
+    }>, "many">;
+    /** Whether result was unanimous */
+    unanimous: z.ZodBoolean;
+    /** Margin of victory */
+    margin: z.ZodNumber;
+}, "strip", z.ZodTypeAny, {
+    winner: string;
+    votes: Record<string, number>;
+    unanimous: boolean;
+    weightedVotes: Record<string, number>;
+    voteRecords: {
+        provider: string;
+        confidence: number;
+        choice: string;
+        reasoning?: string | undefined;
+    }[];
+    margin: number;
+}, {
+    winner: string;
+    votes: Record<string, number>;
+    unanimous: boolean;
+    weightedVotes: Record<string, number>;
+    voteRecords: {
+        provider: string;
+        confidence: number;
+        choice: string;
+        reasoning?: string | undefined;
+    }[];
+    margin: number;
+}>;
+export type VotingResults = z.infer<typeof VotingResultsSchema>;
+/**
+ * Dissenting opinion record
+ */
+export declare const DissentRecordSchema: z.ZodObject<{
+    /** Provider with dissenting view */
+    provider: z.ZodString;
+    /** Summary of dissenting position */
+    position: z.ZodString;
+    /** Key points of disagreement */
+    keyPoints: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
+}, "strip", z.ZodTypeAny, {
+    position: string;
+    provider: string;
+    keyPoints?: string[] | undefined;
+}, {
+    position: string;
+    provider: string;
+    keyPoints?: string[] | undefined;
+}>;
+export type DissentRecord = z.infer<typeof DissentRecordSchema>;
+/**
+ * Consensus details
+ */
+export declare const ConsensusResultSchema: z.ZodObject<{
+    /** Method used to reach consensus */
+    method: z.ZodEnum<["synthesis", "voting", "moderator", "unanimous", "majority"]>;
+    /** Provider that synthesized/moderated */
+    synthesizer: z.ZodOptional<z.ZodString>;
+    /** Agreement score (0-1, how much providers agreed) */
+    agreementScore: z.ZodOptional<z.ZodNumber>;
+    /** Areas of strong agreement */
+    agreements: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
+    /** Dissenting opinions */
+    dissent: z.ZodOptional<z.ZodArray<z.ZodObject<{
+        /** Provider with dissenting view */
+        provider: z.ZodString;
+        /** Summary of dissenting position */
+        position: z.ZodString;
+        /** Key points of disagreement */
+        keyPoints: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
+    }, "strip", z.ZodTypeAny, {
+        position: string;
+        provider: string;
+        keyPoints?: string[] | undefined;
+    }, {
+        position: string;
+        provider: string;
+        keyPoints?: string[] | undefined;
+    }>, "many">>;
+}, "strip", z.ZodTypeAny, {
+    method: "voting" | "synthesis" | "moderator" | "unanimous" | "majority";
+    synthesizer?: string | undefined;
+    agreementScore?: number | undefined;
+    agreements?: string[] | undefined;
+    dissent?: {
+        position: string;
+        provider: string;
+        keyPoints?: string[] | undefined;
+    }[] | undefined;
+}, {
+    method: "voting" | "synthesis" | "moderator" | "unanimous" | "majority";
+    synthesizer?: string | undefined;
+    agreementScore?: number | undefined;
+    agreements?: string[] | undefined;
+    dissent?: {
+        position: string;
+        provider: string;
+        keyPoints?: string[] | undefined;
+    }[] | undefined;
+}>;
+export type ConsensusResult = z.infer<typeof ConsensusResultSchema>;
+/**
+ * Discussion error details
+ */
+export declare const DiscussionErrorSchema: z.ZodObject<{
+    /** Error code */
+    code: z.ZodString;
+    /** Human-readable message */
+    message: z.ZodString;
+    /** Provider that caused error (if applicable) */
+    provider: z.ZodOptional<z.ZodString>;
+    /** Whether error is retryable */
+    retryable: z.ZodOptional<z.ZodBoolean>;
+}, "strip", z.ZodTypeAny, {
+    code: string;
+    message: string;
+    retryable?: boolean | undefined;
+    provider?: string | undefined;
+}, {
+    code: string;
+    message: string;
+    retryable?: boolean | undefined;
+    provider?: string | undefined;
+}>;
+export type DiscussionError = z.infer<typeof DiscussionErrorSchema>;
+/**
+ * Discussion metadata
+ */
+export declare const DiscussionMetadataSchema: z.ZodObject<{
+    /** When discussion started */
+    startedAt: z.ZodString;
+    /** When discussion completed */
+    completedAt: z.ZodString;
+    /** Total tokens used (if available) */
+    totalTokens: z.ZodOptional<z.ZodNumber>;
+    /** Estimated cost in USD (if available) */
+    estimatedCost: z.ZodOptional<z.ZodNumber>;
+    /** Session ID if associated */
+    sessionId: z.ZodOptional<z.ZodString>;
+    /** Trace ID for debugging */
+    traceId: z.ZodOptional<z.ZodString>;
+}, "strip", z.ZodTypeAny, {
+    completedAt: string;
+    startedAt: string;
+    sessionId?: string | undefined;
+    traceId?: string | undefined;
+    totalTokens?: number | undefined;
+    estimatedCost?: number | undefined;
+}, {
+    completedAt: string;
+    startedAt: string;
+    sessionId?: string | undefined;
+    traceId?: string | undefined;
+    totalTokens?: number | undefined;
+    estimatedCost?: number | undefined;
+}>;
+export type DiscussionMetadata = z.infer<typeof DiscussionMetadataSchema>;
+/**
+ * Complete discussion result
+ *
+ * Invariants:
+ * - INV-DISC-009: Result always contains synthesis
+ * - INV-DISC-010: participatingProviders >= minProviders (when successful)
+ */
+export declare const DiscussionResultSchema: z.ZodObject<{
+    /** Whether discussion completed successfully */
+    success: z.ZodBoolean;
+    /** Discussion pattern used */
+    pattern: z.ZodEnum<["round-robin", "debate", "critique", "voting", "synthesis"]>;
+    /** Original topic/prompt */
+    topic: z.ZodString;
+    /** Providers that participated */
+    participatingProviders: z.ZodArray<z.ZodString, "many">;
+    /** Providers that failed */
+    failedProviders: z.ZodArray<z.ZodString, "many">;
+    /** All discussion rounds */
+    rounds: z.ZodArray<z.ZodObject<{
+        /** Round number (1-indexed) */
+        roundNumber: z.ZodNumber;
+        /** Responses from each provider */
+        responses: z.ZodArray<z.ZodObject<{
+            /** Provider that generated this response */
+            provider: z.ZodString;
+            /** Response content */
+            content: z.ZodString;
+            /** Round number (1-indexed) */
+            round: z.ZodNumber;
+            /** Role in discussion (if applicable) */
+            role: z.ZodOptional<z.ZodEnum<["proponent", "opponent", "judge", "moderator", "neutral"]>>;
+            /** Confidence score (0-1) for voting */
+            confidence: z.ZodOptional<z.ZodNumber>;
+            /** Vote choice (for voting pattern) */
+            vote: z.ZodOptional<z.ZodString>;
+            /** Response timestamp */
+            timestamp: z.ZodString;
+            /** Duration in ms */
+            durationMs: z.ZodNumber;
+            /** Token count (if available) */
+            tokenCount: z.ZodOptional<z.ZodNumber>;
+            /** Whether response was truncated */
+            truncated: z.ZodOptional<z.ZodBoolean>;
+            /** Error if response failed */
+            error: z.ZodOptional<z.ZodString>;
+        }, "strip", z.ZodTypeAny, {
+            timestamp: string;
+            durationMs: number;
+            content: string;
+            provider: string;
+            round: number;
+            error?: string | undefined;
+            role?: "moderator" | "proponent" | "opponent" | "judge" | "neutral" | undefined;
+            tokenCount?: number | undefined;
+            truncated?: boolean | undefined;
+            confidence?: number | undefined;
+            vote?: string | undefined;
+        }, {
+            timestamp: string;
+            durationMs: number;
+            content: string;
+            provider: string;
+            round: number;
+            error?: string | undefined;
+            role?: "moderator" | "proponent" | "opponent" | "judge" | "neutral" | undefined;
+            tokenCount?: number | undefined;
+            truncated?: boolean | undefined;
+            confidence?: number | undefined;
+            vote?: string | undefined;
+        }>, "many">;
+        /** Round summary (if generated) */
+        summary: z.ZodOptional<z.ZodString>;
+        /** Round duration in ms */
+        durationMs: z.ZodNumber;
+    }, "strip", z.ZodTypeAny, {
+        durationMs: number;
+        roundNumber: number;
+        responses: {
+            timestamp: string;
+            durationMs: number;
+            content: string;
+            provider: string;
+            round: number;
+            error?: string | undefined;
+            role?: "moderator" | "proponent" | "opponent" | "judge" | "neutral" | undefined;
+            tokenCount?: number | undefined;
+            truncated?: boolean | undefined;
+            confidence?: number | undefined;
+            vote?: string | undefined;
+        }[];
+        summary?: string | undefined;
+    }, {
+        durationMs: number;
+        roundNumber: number;
+        responses: {
+            timestamp: string;
+            durationMs: number;
+            content: string;
+            provider: string;
+            round: number;
+            error?: string | undefined;
+            role?: "moderator" | "proponent" | "opponent" | "judge" | "neutral" | undefined;
+            tokenCount?: number | undefined;
+            truncated?: boolean | undefined;
+            confidence?: number | undefined;
+            vote?: string | undefined;
+        }[];
+        summary?: string | undefined;
+    }>, "many">;
+    /** Final synthesized output */
+    synthesis: z.ZodString;
+    /** Consensus details */
+    consensus: z.ZodObject<{
+        /** Method used to reach consensus */
+        method: z.ZodEnum<["synthesis", "voting", "moderator", "unanimous", "majority"]>;
+        /** Provider that synthesized/moderated */
+        synthesizer: z.ZodOptional<z.ZodString>;
+        /** Agreement score (0-1, how much providers agreed) */
+        agreementScore: z.ZodOptional<z.ZodNumber>;
+        /** Areas of strong agreement */
+        agreements: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
+        /** Dissenting opinions */
+        dissent: z.ZodOptional<z.ZodArray<z.ZodObject<{
+            /** Provider with dissenting view */
+            provider: z.ZodString;
+            /** Summary of dissenting position */
+            position: z.ZodString;
+            /** Key points of disagreement */
+            keyPoints: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
+        }, "strip", z.ZodTypeAny, {
+            position: string;
+            provider: string;
+            keyPoints?: string[] | undefined;
+        }, {
+            position: string;
+            provider: string;
+            keyPoints?: string[] | undefined;
+        }>, "many">>;
+    }, "strip", z.ZodTypeAny, {
+        method: "voting" | "synthesis" | "moderator" | "unanimous" | "majority";
+        synthesizer?: string | undefined;
+        agreementScore?: number | undefined;
+        agreements?: string[] | undefined;
+        dissent?: {
+            position: string;
+            provider: string;
+            keyPoints?: string[] | undefined;
+        }[] | undefined;
+    }, {
+        method: "voting" | "synthesis" | "moderator" | "unanimous" | "majority";
+        synthesizer?: string | undefined;
+        agreementScore?: number | undefined;
+        agreements?: string[] | undefined;
+        dissent?: {
+            position: string;
+            provider: string;
+            keyPoints?: string[] | undefined;
+        }[] | undefined;
+    }>;
+    /** Voting results (for voting pattern) */
+    votingResults: z.ZodOptional<z.ZodObject<{
+        /** Winning option */
+        winner: z.ZodString;
+        /** Raw vote counts per option */
+        votes: z.ZodRecord<z.ZodString, z.ZodNumber>;
+        /** Confidence-weighted vote counts */
+        weightedVotes: z.ZodRecord<z.ZodString, z.ZodNumber>;
+        /** Individual vote records */
+        voteRecords: z.ZodArray<z.ZodObject<{
+            /** Provider that cast the vote */
+            provider: z.ZodString;
+            /** Selected option */
+            choice: z.ZodString;
+            /** Confidence in the vote (0-1) */
+            confidence: z.ZodNumber;
+            /** Reasoning for the vote */
+            reasoning: z.ZodOptional<z.ZodString>;
+        }, "strip", z.ZodTypeAny, {
+            provider: string;
+            confidence: number;
+            choice: string;
+            reasoning?: string | undefined;
+        }, {
+            provider: string;
+            confidence: number;
+            choice: string;
+            reasoning?: string | undefined;
+        }>, "many">;
+        /** Whether result was unanimous */
+        unanimous: z.ZodBoolean;
+        /** Margin of victory */
+        margin: z.ZodNumber;
+    }, "strip", z.ZodTypeAny, {
+        winner: string;
+        votes: Record<string, number>;
+        unanimous: boolean;
+        weightedVotes: Record<string, number>;
+        voteRecords: {
+            provider: string;
+            confidence: number;
+            choice: string;
+            reasoning?: string | undefined;
+        }[];
+        margin: number;
+    }, {
+        winner: string;
+        votes: Record<string, number>;
+        unanimous: boolean;
+        weightedVotes: Record<string, number>;
+        voteRecords: {
+            provider: string;
+            confidence: number;
+            choice: string;
+            reasoning?: string | undefined;
+        }[];
+        margin: number;
+    }>>;
+    /** Total duration in ms */
+    totalDurationMs: z.ZodNumber;
+    /** Discussion metadata */
+    metadata: z.ZodObject<{
+        /** When discussion started */
+        startedAt: z.ZodString;
+        /** When discussion completed */
+        completedAt: z.ZodString;
+        /** Total tokens used (if available) */
+        totalTokens: z.ZodOptional<z.ZodNumber>;
+        /** Estimated cost in USD (if available) */
+        estimatedCost: z.ZodOptional<z.ZodNumber>;
+        /** Session ID if associated */
+        sessionId: z.ZodOptional<z.ZodString>;
+        /** Trace ID for debugging */
+        traceId: z.ZodOptional<z.ZodString>;
+    }, "strip", z.ZodTypeAny, {
+        completedAt: string;
+        startedAt: string;
+        sessionId?: string | undefined;
+        traceId?: string | undefined;
+        totalTokens?: number | undefined;
+        estimatedCost?: number | undefined;
+    }, {
+        completedAt: string;
+        startedAt: string;
+        sessionId?: string | undefined;
+        traceId?: string | undefined;
+        totalTokens?: number | undefined;
+        estimatedCost?: number | undefined;
+    }>;
+    /** Error if discussion failed */
+    error: z.ZodOptional<z.ZodObject<{
+        /** Error code */
+        code: z.ZodString;
+        /** Human-readable message */
+        message: z.ZodString;
+        /** Provider that caused error (if applicable) */
+        provider: z.ZodOptional<z.ZodString>;
+        /** Whether error is retryable */
+        retryable: z.ZodOptional<z.ZodBoolean>;
+    }, "strip", z.ZodTypeAny, {
+        code: string;
+        message: string;
+        retryable?: boolean | undefined;
+        provider?: string | undefined;
+    }, {
+        code: string;
+        message: string;
+        retryable?: boolean | undefined;
+        provider?: string | undefined;
+    }>>;
+}, "strip", z.ZodTypeAny, {
+    metadata: {
+        completedAt: string;
+        startedAt: string;
+        sessionId?: string | undefined;
+        traceId?: string | undefined;
+        totalTokens?: number | undefined;
+        estimatedCost?: number | undefined;
+    };
+    success: boolean;
+    totalDurationMs: number;
+    pattern: "round-robin" | "debate" | "critique" | "voting" | "synthesis";
+    rounds: {
+        durationMs: number;
+        roundNumber: number;
+        responses: {
+            timestamp: string;
+            durationMs: number;
+            content: string;
+            provider: string;
+            round: number;
+            error?: string | undefined;
+            role?: "moderator" | "proponent" | "opponent" | "judge" | "neutral" | undefined;
+            tokenCount?: number | undefined;
+            truncated?: boolean | undefined;
+            confidence?: number | undefined;
+            vote?: string | undefined;
+        }[];
+        summary?: string | undefined;
+    }[];
+    topic: string;
+    participatingProviders: string[];
+    failedProviders: string[];
+    synthesis: string;
+    consensus: {
+        method: "voting" | "synthesis" | "moderator" | "unanimous" | "majority";
+        synthesizer?: string | undefined;
+        agreementScore?: number | undefined;
+        agreements?: string[] | undefined;
+        dissent?: {
+            position: string;
+            provider: string;
+            keyPoints?: string[] | undefined;
+        }[] | undefined;
+    };
+    error?: {
+        code: string;
+        message: string;
+        retryable?: boolean | undefined;
+        provider?: string | undefined;
+    } | undefined;
+    votingResults?: {
+        winner: string;
+        votes: Record<string, number>;
+        unanimous: boolean;
+        weightedVotes: Record<string, number>;
+        voteRecords: {
+            provider: string;
+            confidence: number;
+            choice: string;
+            reasoning?: string | undefined;
+        }[];
+        margin: number;
+    } | undefined;
+}, {
+    metadata: {
+        completedAt: string;
+        startedAt: string;
+        sessionId?: string | undefined;
+        traceId?: string | undefined;
+        totalTokens?: number | undefined;
+        estimatedCost?: number | undefined;
+    };
+    success: boolean;
+    totalDurationMs: number;
+    pattern: "round-robin" | "debate" | "critique" | "voting" | "synthesis";
+    rounds: {
+        durationMs: number;
+        roundNumber: number;
+        responses: {
+            timestamp: string;
+            durationMs: number;
+            content: string;
+            provider: string;
+            round: number;
+            error?: string | undefined;
+            role?: "moderator" | "proponent" | "opponent" | "judge" | "neutral" | undefined;
+            tokenCount?: number | undefined;
+            truncated?: boolean | undefined;
+            confidence?: number | undefined;
+            vote?: string | undefined;
+        }[];
+        summary?: string | undefined;
+    }[];
+    topic: string;
+    participatingProviders: string[];
+    failedProviders: string[];
+    synthesis: string;
+    consensus: {
+        method: "voting" | "synthesis" | "moderator" | "unanimous" | "majority";
+        synthesizer?: string | undefined;
+        agreementScore?: number | undefined;
+        agreements?: string[] | undefined;
+        dissent?: {
+            position: string;
+            provider: string;
+            keyPoints?: string[] | undefined;
+        }[] | undefined;
+    };
+    error?: {
+        code: string;
+        message: string;
+        retryable?: boolean | undefined;
+        provider?: string | undefined;
+    } | undefined;
+    votingResults?: {
+        winner: string;
+        votes: Record<string, number>;
+        unanimous: boolean;
+        weightedVotes: Record<string, number>;
+        voteRecords: {
+            provider: string;
+            confidence: number;
+            choice: string;
+            reasoning?: string | undefined;
+        }[];
+        margin: number;
+    } | undefined;
+}>;
+export type DiscussionResult = z.infer<typeof DiscussionResultSchema>;
+/**
+ * Request to start a discussion
+ */
+export declare const DiscussionRequestSchema: z.ZodObject<{
+    /** Topic or question to discuss */
+    topic: z.ZodString;
+    /** Discussion pattern */
+    pattern: z.ZodOptional<z.ZodEnum<["round-robin", "debate", "critique", "voting", "synthesis"]>>;
+    /** Providers to use (defaults to claude, glm, qwen, gemini) */
+    providers: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
+    /** Number of rounds */
+    rounds: z.ZodOptional<z.ZodNumber>;
+    /** Consensus method */
+    consensusMethod: z.ZodOptional<z.ZodEnum<["synthesis", "voting", "moderator", "unanimous", "majority"]>>;
+    /** Options for voting pattern */
+    votingOptions: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
+    /** Additional context */
+    context: z.ZodOptional<z.ZodString>;
+    /** Session ID to associate with */
+    sessionId: z.ZodOptional<z.ZodString>;
+    /** Enable verbose output */
+    verbose: z.ZodOptional<z.ZodBoolean>;
+}, "strip", z.ZodTypeAny, {
+    topic: string;
+    context?: string | undefined;
+    sessionId?: string | undefined;
+    pattern?: "round-robin" | "debate" | "critique" | "voting" | "synthesis" | undefined;
+    providers?: string[] | undefined;
+    rounds?: number | undefined;
+    consensusMethod?: "voting" | "synthesis" | "moderator" | "unanimous" | "majority" | undefined;
+    verbose?: boolean | undefined;
+    votingOptions?: string[] | undefined;
+}, {
+    topic: string;
+    context?: string | undefined;
+    sessionId?: string | undefined;
+    pattern?: "round-robin" | "debate" | "critique" | "voting" | "synthesis" | undefined;
+    providers?: string[] | undefined;
+    rounds?: number | undefined;
+    consensusMethod?: "voting" | "synthesis" | "moderator" | "unanimous" | "majority" | undefined;
+    verbose?: boolean | undefined;
+    votingOptions?: string[] | undefined;
+}>;
+export type DiscussionRequest = z.infer<typeof DiscussionRequestSchema>;
+export declare const DiscussionErrorCodes: {
+    /** Not enough providers available */
+    readonly INSUFFICIENT_PROVIDERS: "DISCUSSION_INSUFFICIENT_PROVIDERS";
+    /** Provider timed out */
+    readonly PROVIDER_TIMEOUT: "DISCUSSION_PROVIDER_TIMEOUT";
+    /** All providers failed */
+    readonly ALL_PROVIDERS_FAILED: "DISCUSSION_ALL_PROVIDERS_FAILED";
+    /** Failed to reach consensus */
+    readonly CONSENSUS_FAILED: "DISCUSSION_CONSENSUS_FAILED";
+    /** Invalid pattern specified */
+    readonly INVALID_PATTERN: "DISCUSSION_INVALID_PATTERN";
+    /** Invalid role assignments */
+    readonly INVALID_ROLES: "DISCUSSION_INVALID_ROLES";
+    /** Synthesis step failed */
+    readonly SYNTHESIS_FAILED: "DISCUSSION_SYNTHESIS_FAILED";
+    /** Invalid configuration */
+    readonly INVALID_CONFIG: "DISCUSSION_INVALID_CONFIG";
+    /** Provider not found */
+    readonly PROVIDER_NOT_FOUND: "DISCUSSION_PROVIDER_NOT_FOUND";
+};
+export type DiscussionErrorCode = (typeof DiscussionErrorCodes)[keyof typeof DiscussionErrorCodes];
+/**
+ * Validates discussion step configuration
+ * @throws ZodError if validation fails
+ */
+export declare function validateDiscussStepConfig(data: unknown): DiscussStepConfig;
+/**
+ * Safely validates discussion step configuration
+ */
+export declare function safeValidateDiscussStepConfig(data: unknown): {
+    success: true;
+    data: DiscussStepConfig;
+} | {
+    success: false;
+    error: z.ZodError;
+};
+/**
+ * Validates discussion request
+ * @throws ZodError if validation fails
+ */
+export declare function validateDiscussionRequest(data: unknown): DiscussionRequest;
+/**
+ * Safely validates discussion request
+ */
+export declare function safeValidateDiscussionRequest(data: unknown): {
+    success: true;
+    data: DiscussionRequest;
+} | {
+    success: false;
+    error: z.ZodError;
+};
+/**
+ * Validates discussion result
+ * @throws ZodError if validation fails
+ */
+export declare function validateDiscussionResult(data: unknown): DiscussionResult;
+/**
+ * Safely validates discussion result
+ */
+export declare function safeValidateDiscussionResult(data: unknown): {
+    success: true;
+    data: DiscussionResult;
+} | {
+    success: false;
+    error: z.ZodError;
+};
+/**
+ * Creates default discussion step config
+ */
+export declare function createDefaultDiscussStepConfig(prompt: string, providers?: string[]): DiscussStepConfig;
+/**
+ * Creates a debate configuration
+ */
+export declare function createDebateConfig(prompt: string, proponent?: string, opponent?: string, judge?: string): DiscussStepConfig;
+/**
+ * Creates a voting configuration
+ */
+export declare function createVotingConfig(prompt: string, options: string[], providers?: string[]): DiscussStepConfig;
+/**
+ * Creates an empty successful discussion result
+ */
+export declare function createEmptyDiscussionResult(pattern: DiscussionPattern, topic: string): DiscussionResult;
+/**
+ * Creates a failed discussion result
+ */
+export declare function createFailedDiscussionResult(pattern: DiscussionPattern, topic: string, errorCode: DiscussionErrorCode, errorMessage: string, startedAt: string): DiscussionResult;
+//# sourceMappingURL=schema.d.ts.map