@defai.digital/contracts 13.0.3 → 13.1.0

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

@@ -21,6 +21,18 @@ export declare const DEFAULT_PROVIDER_TIMEOUT = 60000;
 export declare const MAX_PROVIDER_TIMEOUT = 300000;
 /** Default providers for discussions */
 export declare const DEFAULT_PROVIDERS: readonly ["claude", "glm", "qwen", "gemini"];
+/** Maximum discussion depth for recursive discussions */
+export declare const MAX_DISCUSSION_DEPTH = 4;
+/** Default discussion depth */
+export declare const DEFAULT_DISCUSSION_DEPTH = 2;
+/** Minimum time reserved for synthesis at each level (ms) */
+export declare const MIN_SYNTHESIS_TIME_MS = 10000;
+/** Default total budget for recursive discussions (ms) */
+export declare const DEFAULT_TOTAL_BUDGET_MS = 180000;
+/** Default maximum total provider calls across nested discussions */
+export declare const DEFAULT_MAX_TOTAL_CALLS = 20;
+/** Default cascading confidence threshold for early exit */
+export declare const DEFAULT_CONFIDENCE_THRESHOLD = 0.9;
 /**
  * Discussion patterns supported by the system
  *
@@ -100,6 +112,33 @@ export type ProviderCapability = z.infer<typeof ProviderCapabilitySchema>;
  * Provider strength mapping (for routing decisions)
  */
 export declare const PROVIDER_STRENGTHS: Record<string, ProviderCapability[]>;
+/**
+ * Participant in a discussion (provider or agent)
+ *
+ * Invariants:
+ * - INV-DISC-640: Agent participants use providerAffinity.preferred[0]
+ * - INV-DISC-641: Agent abilities injected with max 10K tokens
+ */
+export declare const DiscussionParticipantSchema: z.ZodDiscriminatedUnion<"type", [z.ZodObject<{
+    type: z.ZodLiteral<"provider">;
+    id: z.ZodString;
+}, "strip", z.ZodTypeAny, {
+    type: "provider";
+    id: string;
+}, {
+    type: "provider";
+    id: string;
+}>, z.ZodObject<{
+    type: z.ZodLiteral<"agent">;
+    id: z.ZodString;
+}, "strip", z.ZodTypeAny, {
+    type: "agent";
+    id: string;
+}, {
+    type: "agent";
+    id: string;
+}>]>;
+export type DiscussionParticipant = z.infer<typeof DiscussionParticipantSchema>;
 /**
  * Configuration for a discuss workflow step
  *
@@ -171,6 +210,28 @@ export declare const DiscussStepConfigSchema: z.ZodEffects<z.ZodEffects<z.ZodObj
     verbose: z.ZodDefault<z.ZodBoolean>;
     /** Additional context for all providers */
     context: z.ZodOptional<z.ZodString>;
+    /** Mix of providers and agents as participants (alternative to providers array) */
+    participants: z.ZodOptional<z.ZodArray<z.ZodDiscriminatedUnion<"type", [z.ZodObject<{
+        type: z.ZodLiteral<"provider">;
+        id: z.ZodString;
+    }, "strip", z.ZodTypeAny, {
+        type: "provider";
+        id: string;
+    }, {
+        type: "provider";
+        id: string;
+    }>, z.ZodObject<{
+        type: z.ZodLiteral<"agent">;
+        id: z.ZodString;
+    }, "strip", z.ZodTypeAny, {
+        type: "agent";
+        id: string;
+    }, {
+        type: "agent";
+        id: string;
+    }>]>, "many">>;
+    /** Weight multiplier for agent responses in consensus (default: 1.5x) */
+    agentWeightMultiplier: z.ZodDefault<z.ZodOptional<z.ZodNumber>>;
 }, "strip", z.ZodTypeAny, {
     prompt: string;
     pattern: "round-robin" | "debate" | "critique" | "voting" | "synthesis";
@@ -188,13 +249,28 @@ export declare const DiscussStepConfigSchema: z.ZodEffects<z.ZodEffects<z.ZodObj
     providerTimeout: number;
     continueOnProviderFailure: boolean;
     minProviders: number;
+    agentWeightMultiplier: number;
     context?: string | undefined;
+    participants?: ({
+        type: "provider";
+        id: string;
+    } | {
+        type: "agent";
+        id: string;
+    })[] | undefined;
     providerPrompts?: Record<string, string> | undefined;
     roles?: Record<string, "moderator" | "proponent" | "opponent" | "judge" | "neutral"> | undefined;
 }, {
     prompt: string;
     providers: string[];
     context?: string | undefined;
+    participants?: ({
+        type: "provider";
+        id: string;
+    } | {
+        type: "agent";
+        id: string;
+    })[] | undefined;
     pattern?: "round-robin" | "debate" | "critique" | "voting" | "synthesis" | undefined;
     rounds?: number | undefined;
     temperature?: number | undefined;
@@ -211,6 +287,7 @@ export declare const DiscussStepConfigSchema: z.ZodEffects<z.ZodEffects<z.ZodObj
     providerTimeout?: number | undefined;
     continueOnProviderFailure?: boolean | undefined;
     minProviders?: number | undefined;
+    agentWeightMultiplier?: number | undefined;
 }>, {
     prompt: string;
     pattern: "round-robin" | "debate" | "critique" | "voting" | "synthesis";
@@ -228,13 +305,28 @@ export declare const DiscussStepConfigSchema: z.ZodEffects<z.ZodEffects<z.ZodObj
     providerTimeout: number;
     continueOnProviderFailure: boolean;
     minProviders: number;
+    agentWeightMultiplier: number;
     context?: string | undefined;
+    participants?: ({
+        type: "provider";
+        id: string;
+    } | {
+        type: "agent";
+        id: string;
+    })[] | undefined;
     providerPrompts?: Record<string, string> | undefined;
     roles?: Record<string, "moderator" | "proponent" | "opponent" | "judge" | "neutral"> | undefined;
 }, {
     prompt: string;
     providers: string[];
     context?: string | undefined;
+    participants?: ({
+        type: "provider";
+        id: string;
+    } | {
+        type: "agent";
+        id: string;
+    })[] | undefined;
     pattern?: "round-robin" | "debate" | "critique" | "voting" | "synthesis" | undefined;
     rounds?: number | undefined;
     temperature?: number | undefined;
@@ -251,6 +343,7 @@ export declare const DiscussStepConfigSchema: z.ZodEffects<z.ZodEffects<z.ZodObj
     providerTimeout?: number | undefined;
     continueOnProviderFailure?: boolean | undefined;
     minProviders?: number | undefined;
+    agentWeightMultiplier?: number | undefined;
 }>, {
     prompt: string;
     pattern: "round-robin" | "debate" | "critique" | "voting" | "synthesis";
@@ -268,13 +361,28 @@ export declare const DiscussStepConfigSchema: z.ZodEffects<z.ZodEffects<z.ZodObj
     providerTimeout: number;
     continueOnProviderFailure: boolean;
     minProviders: number;
+    agentWeightMultiplier: number;
     context?: string | undefined;
+    participants?: ({
+        type: "provider";
+        id: string;
+    } | {
+        type: "agent";
+        id: string;
+    })[] | undefined;
     providerPrompts?: Record<string, string> | undefined;
     roles?: Record<string, "moderator" | "proponent" | "opponent" | "judge" | "neutral"> | undefined;
 }, {
     prompt: string;
     providers: string[];
     context?: string | undefined;
+    participants?: ({
+        type: "provider";
+        id: string;
+    } | {
+        type: "agent";
+        id: string;
+    })[] | undefined;
     pattern?: "round-robin" | "debate" | "critique" | "voting" | "synthesis" | undefined;
     rounds?: number | undefined;
     temperature?: number | undefined;
@@ -291,6 +399,7 @@ export declare const DiscussStepConfigSchema: z.ZodEffects<z.ZodEffects<z.ZodObj
     providerTimeout?: number | undefined;
     continueOnProviderFailure?: boolean | undefined;
     minProviders?: number | undefined;
+    agentWeightMultiplier?: number | undefined;
 }>;
 export type DiscussStepConfig = z.infer<typeof DiscussStepConfigSchema>;
 /**
@@ -320,30 +429,38 @@ export declare const DiscussionProviderResponseSchema: z.ZodObject<{
     truncated: z.ZodOptional<z.ZodBoolean>;
     /** Error if response failed */
     error: z.ZodOptional<z.ZodString>;
+    /** Whether response is from an agent (vs raw provider) */
+    isAgent: z.ZodOptional<z.ZodBoolean>;
+    /** Agent ID if response is from an agent */
+    agentId: z.ZodOptional<z.ZodString>;
 }, "strip", z.ZodTypeAny, {
     timestamp: string;
     durationMs: number;
     content: string;
     provider: string;
     round: number;
+    agentId?: string | undefined;
     error?: string | undefined;
     role?: "moderator" | "proponent" | "opponent" | "judge" | "neutral" | undefined;
     tokenCount?: number | undefined;
     truncated?: boolean | undefined;
     confidence?: number | undefined;
     vote?: string | undefined;
+    isAgent?: boolean | undefined;
 }, {
     timestamp: string;
     durationMs: number;
     content: string;
     provider: string;
     round: number;
+    agentId?: string | undefined;
     error?: string | undefined;
     role?: "moderator" | "proponent" | "opponent" | "judge" | "neutral" | undefined;
     tokenCount?: number | undefined;
     truncated?: boolean | undefined;
     confidence?: number | undefined;
     vote?: string | undefined;
+    isAgent?: boolean | undefined;
 }>;
 export type DiscussionProviderResponse = z.infer<typeof DiscussionProviderResponseSchema>;
 /**
@@ -376,30 +493,38 @@ export declare const DiscussionRoundSchema: z.ZodObject<{
         truncated: z.ZodOptional<z.ZodBoolean>;
         /** Error if response failed */
         error: z.ZodOptional<z.ZodString>;
+        /** Whether response is from an agent (vs raw provider) */
+        isAgent: z.ZodOptional<z.ZodBoolean>;
+        /** Agent ID if response is from an agent */
+        agentId: z.ZodOptional<z.ZodString>;
     }, "strip", z.ZodTypeAny, {
         timestamp: string;
         durationMs: number;
         content: string;
         provider: string;
         round: number;
+        agentId?: string | undefined;
         error?: string | undefined;
         role?: "moderator" | "proponent" | "opponent" | "judge" | "neutral" | undefined;
         tokenCount?: number | undefined;
         truncated?: boolean | undefined;
         confidence?: number | undefined;
         vote?: string | undefined;
+        isAgent?: boolean | undefined;
     }, {
         timestamp: string;
         durationMs: number;
         content: string;
         provider: string;
         round: number;
+        agentId?: string | undefined;
         error?: string | undefined;
         role?: "moderator" | "proponent" | "opponent" | "judge" | "neutral" | undefined;
         tokenCount?: number | undefined;
         truncated?: boolean | undefined;
         confidence?: number | undefined;
         vote?: string | undefined;
+        isAgent?: boolean | undefined;
     }>, "many">;
     /** Round summary (if generated) */
     summary: z.ZodOptional<z.ZodString>;
@@ -414,12 +539,14 @@ export declare const DiscussionRoundSchema: z.ZodObject<{
         content: string;
         provider: string;
         round: number;
+        agentId?: string | undefined;
         error?: string | undefined;
         role?: "moderator" | "proponent" | "opponent" | "judge" | "neutral" | undefined;
         tokenCount?: number | undefined;
         truncated?: boolean | undefined;
         confidence?: number | undefined;
         vote?: string | undefined;
+        isAgent?: boolean | undefined;
     }[];
     summary?: string | undefined;
 }, {
@@ -431,12 +558,14 @@ export declare const DiscussionRoundSchema: z.ZodObject<{
         content: string;
         provider: string;
         round: number;
+        agentId?: string | undefined;
         error?: string | undefined;
         role?: "moderator" | "proponent" | "opponent" | "judge" | "neutral" | undefined;
         tokenCount?: number | undefined;
         truncated?: boolean | undefined;
         confidence?: number | undefined;
         vote?: string | undefined;
+        isAgent?: boolean | undefined;
     }[];
     summary?: string | undefined;
 }>;
@@ -621,6 +750,83 @@ export declare const DiscussionErrorSchema: z.ZodObject<{
     provider?: string | undefined;
 }>;
 export type DiscussionError = z.infer<typeof DiscussionErrorSchema>;
+/**
+ * Cost summary for discussion tracking
+ *
+ * Invariants:
+ * - INV-DISC-620: Total calls ≤ maxTotalCalls
+ * - INV-DISC-621: Abort if cost budget exceeded
+ * - INV-DISC-644: Cost summary included when tracking enabled
+ */
+export declare const CostSummarySchema: z.ZodObject<{
+    /** Total provider calls made */
+    totalCalls: z.ZodNumber;
+    /** Total tokens used */
+    totalTokens: z.ZodNumber;
+    /** Estimated cost in USD */
+    estimatedCostUsd: z.ZodNumber;
+    /** Breakdown by provider */
+    byProvider: z.ZodRecord<z.ZodString, z.ZodObject<{
+        calls: z.ZodNumber;
+        tokens: z.ZodNumber;
+        cost: z.ZodNumber;
+    }, "strip", z.ZodTypeAny, {
+        tokens: number;
+        cost: number;
+        calls: number;
+    }, {
+        tokens: number;
+        cost: number;
+        calls: number;
+    }>>;
+}, "strip", z.ZodTypeAny, {
+    totalTokens: number;
+    byProvider: Record<string, {
+        tokens: number;
+        cost: number;
+        calls: number;
+    }>;
+    totalCalls: number;
+    estimatedCostUsd: number;
+}, {
+    totalTokens: number;
+    byProvider: Record<string, {
+        tokens: number;
+        cost: number;
+        calls: number;
+    }>;
+    totalCalls: number;
+    estimatedCostUsd: number;
+}>;
+export type CostSummary = z.infer<typeof CostSummarySchema>;
+/**
+ * Early exit decision info
+ *
+ * Invariants:
+ * - INV-DISC-622: Confidence threshold configurable (default 0.9)
+ * - INV-DISC-643: Early exit only after minProviders responded
+ */
+export declare const EarlyExitInfoSchema: z.ZodObject<{
+    /** Whether early exit was triggered */
+    triggered: z.ZodBoolean;
+    /** Reason for early exit decision */
+    reason: z.ZodOptional<z.ZodString>;
+    /** Number of providers that had responded when decision was made */
+    atProviderCount: z.ZodOptional<z.ZodNumber>;
+    /** Confidence score that triggered the exit */
+    confidenceScore: z.ZodOptional<z.ZodNumber>;
+}, "strip", z.ZodTypeAny, {
+    triggered: boolean;
+    reason?: string | undefined;
+    atProviderCount?: number | undefined;
+    confidenceScore?: number | undefined;
+}, {
+    triggered: boolean;
+    reason?: string | undefined;
+    atProviderCount?: number | undefined;
+    confidenceScore?: number | undefined;
+}>;
+export type EarlyExitInfo = z.infer<typeof EarlyExitInfoSchema>;
 /**
  * Discussion metadata
  */
@@ -637,6 +843,68 @@ export declare const DiscussionMetadataSchema: z.ZodObject<{
     sessionId: z.ZodOptional<z.ZodString>;
     /** Trace ID for debugging */
     traceId: z.ZodOptional<z.ZodString>;
+    /** Cost tracking summary */
+    costSummary: z.ZodOptional<z.ZodObject<{
+        /** Total provider calls made */
+        totalCalls: z.ZodNumber;
+        /** Total tokens used */
+        totalTokens: z.ZodNumber;
+        /** Estimated cost in USD */
+        estimatedCostUsd: z.ZodNumber;
+        /** Breakdown by provider */
+        byProvider: z.ZodRecord<z.ZodString, z.ZodObject<{
+            calls: z.ZodNumber;
+            tokens: z.ZodNumber;
+            cost: z.ZodNumber;
+        }, "strip", z.ZodTypeAny, {
+            tokens: number;
+            cost: number;
+            calls: number;
+        }, {
+            tokens: number;
+            cost: number;
+            calls: number;
+        }>>;
+    }, "strip", z.ZodTypeAny, {
+        totalTokens: number;
+        byProvider: Record<string, {
+            tokens: number;
+            cost: number;
+            calls: number;
+        }>;
+        totalCalls: number;
+        estimatedCostUsd: number;
+    }, {
+        totalTokens: number;
+        byProvider: Record<string, {
+            tokens: number;
+            cost: number;
+            calls: number;
+        }>;
+        totalCalls: number;
+        estimatedCostUsd: number;
+    }>>;
+    /** Early exit information */
+    earlyExit: z.ZodOptional<z.ZodObject<{
+        /** Whether early exit was triggered */
+        triggered: z.ZodBoolean;
+        /** Reason for early exit decision */
+        reason: z.ZodOptional<z.ZodString>;
+        /** Number of providers that had responded when decision was made */
+        atProviderCount: z.ZodOptional<z.ZodNumber>;
+        /** Confidence score that triggered the exit */
+        confidenceScore: z.ZodOptional<z.ZodNumber>;
+    }, "strip", z.ZodTypeAny, {
+        triggered: boolean;
+        reason?: string | undefined;
+        atProviderCount?: number | undefined;
+        confidenceScore?: number | undefined;
+    }, {
+        triggered: boolean;
+        reason?: string | undefined;
+        atProviderCount?: number | undefined;
+        confidenceScore?: number | undefined;
+    }>>;
 }, "strip", z.ZodTypeAny, {
     completedAt: string;
     startedAt: string;
@@ -644,6 +912,22 @@ export declare const DiscussionMetadataSchema: z.ZodObject<{
     traceId?: string | undefined;
     totalTokens?: number | undefined;
     estimatedCost?: number | undefined;
+    costSummary?: {
+        totalTokens: number;
+        byProvider: Record<string, {
+            tokens: number;
+            cost: number;
+            calls: number;
+        }>;
+        totalCalls: number;
+        estimatedCostUsd: number;
+    } | undefined;
+    earlyExit?: {
+        triggered: boolean;
+        reason?: string | undefined;
+        atProviderCount?: number | undefined;
+        confidenceScore?: number | undefined;
+    } | undefined;
 }, {
     completedAt: string;
     startedAt: string;
@@ -651,6 +935,22 @@ export declare const DiscussionMetadataSchema: z.ZodObject<{
     traceId?: string | undefined;
     totalTokens?: number | undefined;
     estimatedCost?: number | undefined;
+    costSummary?: {
+        totalTokens: number;
+        byProvider: Record<string, {
+            tokens: number;
+            cost: number;
+            calls: number;
+        }>;
+        totalCalls: number;
+        estimatedCostUsd: number;
+    } | undefined;
+    earlyExit?: {
+        triggered: boolean;
+        reason?: string | undefined;
+        atProviderCount?: number | undefined;
+        confidenceScore?: number | undefined;
+    } | undefined;
 }>;
 export type DiscussionMetadata = z.infer<typeof DiscussionMetadataSchema>;
 /**
@@ -699,30 +999,38 @@ export declare const DiscussionResultSchema: z.ZodObject<{
             truncated: z.ZodOptional<z.ZodBoolean>;
             /** Error if response failed */
             error: z.ZodOptional<z.ZodString>;
+            /** Whether response is from an agent (vs raw provider) */
+            isAgent: z.ZodOptional<z.ZodBoolean>;
+            /** Agent ID if response is from an agent */
+            agentId: z.ZodOptional<z.ZodString>;
         }, "strip", z.ZodTypeAny, {
             timestamp: string;
             durationMs: number;
             content: string;
             provider: string;
             round: number;
+            agentId?: string | undefined;
             error?: string | undefined;
             role?: "moderator" | "proponent" | "opponent" | "judge" | "neutral" | undefined;
             tokenCount?: number | undefined;
             truncated?: boolean | undefined;
             confidence?: number | undefined;
             vote?: string | undefined;
+            isAgent?: boolean | undefined;
         }, {
             timestamp: string;
             durationMs: number;
             content: string;
             provider: string;
             round: number;
+            agentId?: string | undefined;
             error?: string | undefined;
             role?: "moderator" | "proponent" | "opponent" | "judge" | "neutral" | undefined;
             tokenCount?: number | undefined;
             truncated?: boolean | undefined;
             confidence?: number | undefined;
             vote?: string | undefined;
+            isAgent?: boolean | undefined;
         }>, "many">;
         /** Round summary (if generated) */
         summary: z.ZodOptional<z.ZodString>;
@@ -737,12 +1045,14 @@ export declare const DiscussionResultSchema: z.ZodObject<{
             content: string;
             provider: string;
             round: number;
+            agentId?: string | undefined;
             error?: string | undefined;
             role?: "moderator" | "proponent" | "opponent" | "judge" | "neutral" | undefined;
             tokenCount?: number | undefined;
             truncated?: boolean | undefined;
             confidence?: number | undefined;
             vote?: string | undefined;
+            isAgent?: boolean | undefined;
         }[];
         summary?: string | undefined;
     }, {
@@ -754,12 +1064,14 @@ export declare const DiscussionResultSchema: z.ZodObject<{
             content: string;
             provider: string;
             round: number;
+            agentId?: string | undefined;
             error?: string | undefined;
             role?: "moderator" | "proponent" | "opponent" | "judge" | "neutral" | undefined;
             tokenCount?: number | undefined;
             truncated?: boolean | undefined;
             confidence?: number | undefined;
             vote?: string | undefined;
+            isAgent?: boolean | undefined;
         }[];
         summary?: string | undefined;
     }>, "many">;
@@ -887,6 +1199,68 @@ export declare const DiscussionResultSchema: z.ZodObject<{
         sessionId: z.ZodOptional<z.ZodString>;
         /** Trace ID for debugging */
         traceId: z.ZodOptional<z.ZodString>;
+        /** Cost tracking summary */
+        costSummary: z.ZodOptional<z.ZodObject<{
+            /** Total provider calls made */
+            totalCalls: z.ZodNumber;
+            /** Total tokens used */
+            totalTokens: z.ZodNumber;
+            /** Estimated cost in USD */
+            estimatedCostUsd: z.ZodNumber;
+            /** Breakdown by provider */
+            byProvider: z.ZodRecord<z.ZodString, z.ZodObject<{
+                calls: z.ZodNumber;
+                tokens: z.ZodNumber;
+                cost: z.ZodNumber;
+            }, "strip", z.ZodTypeAny, {
+                tokens: number;
+                cost: number;
+                calls: number;
+            }, {
+                tokens: number;
+                cost: number;
+                calls: number;
+            }>>;
+        }, "strip", z.ZodTypeAny, {
+            totalTokens: number;
+            byProvider: Record<string, {
+                tokens: number;
+                cost: number;
+                calls: number;
+            }>;
+            totalCalls: number;
+            estimatedCostUsd: number;
+        }, {
+            totalTokens: number;
+            byProvider: Record<string, {
+                tokens: number;
+                cost: number;
+                calls: number;
+            }>;
+            totalCalls: number;
+            estimatedCostUsd: number;
+        }>>;
+        /** Early exit information */
+        earlyExit: z.ZodOptional<z.ZodObject<{
+            /** Whether early exit was triggered */
+            triggered: z.ZodBoolean;
+            /** Reason for early exit decision */
+            reason: z.ZodOptional<z.ZodString>;
+            /** Number of providers that had responded when decision was made */
+            atProviderCount: z.ZodOptional<z.ZodNumber>;
+            /** Confidence score that triggered the exit */
+            confidenceScore: z.ZodOptional<z.ZodNumber>;
+        }, "strip", z.ZodTypeAny, {
+            triggered: boolean;
+            reason?: string | undefined;
+            atProviderCount?: number | undefined;
+            confidenceScore?: number | undefined;
+        }, {
+            triggered: boolean;
+            reason?: string | undefined;
+            atProviderCount?: number | undefined;
+            confidenceScore?: number | undefined;
+        }>>;
     }, "strip", z.ZodTypeAny, {
         completedAt: string;
         startedAt: string;
@@ -894,6 +1268,22 @@ export declare const DiscussionResultSchema: z.ZodObject<{
         traceId?: string | undefined;
         totalTokens?: number | undefined;
         estimatedCost?: number | undefined;
+        costSummary?: {
+            totalTokens: number;
+            byProvider: Record<string, {
+                tokens: number;
+                cost: number;
+                calls: number;
+            }>;
+            totalCalls: number;
+            estimatedCostUsd: number;
+        } | undefined;
+        earlyExit?: {
+            triggered: boolean;
+            reason?: string | undefined;
+            atProviderCount?: number | undefined;
+            confidenceScore?: number | undefined;
+        } | undefined;
     }, {
         completedAt: string;
         startedAt: string;
@@ -901,6 +1291,22 @@ export declare const DiscussionResultSchema: z.ZodObject<{
         traceId?: string | undefined;
         totalTokens?: number | undefined;
         estimatedCost?: number | undefined;
+        costSummary?: {
+            totalTokens: number;
+            byProvider: Record<string, {
+                tokens: number;
+                cost: number;
+                calls: number;
+            }>;
+            totalCalls: number;
+            estimatedCostUsd: number;
+        } | undefined;
+        earlyExit?: {
+            triggered: boolean;
+            reason?: string | undefined;
+            atProviderCount?: number | undefined;
+            confidenceScore?: number | undefined;
+        } | undefined;
     }>;
     /** Error if discussion failed */
     error: z.ZodOptional<z.ZodObject<{
@@ -931,6 +1337,22 @@ export declare const DiscussionResultSchema: z.ZodObject<{
         traceId?: string | undefined;
         totalTokens?: number | undefined;
         estimatedCost?: number | undefined;
+        costSummary?: {
+            totalTokens: number;
+            byProvider: Record<string, {
+                tokens: number;
+                cost: number;
+                calls: number;
+            }>;
+            totalCalls: number;
+            estimatedCostUsd: number;
+        } | undefined;
+        earlyExit?: {
+            triggered: boolean;
+            reason?: string | undefined;
+            atProviderCount?: number | undefined;
+            confidenceScore?: number | undefined;
+        } | undefined;
     };
     success: boolean;
     totalDurationMs: number;
@@ -944,12 +1366,14 @@ export declare const DiscussionResultSchema: z.ZodObject<{
             content: string;
             provider: string;
             round: number;
+            agentId?: string | undefined;
             error?: string | undefined;
             role?: "moderator" | "proponent" | "opponent" | "judge" | "neutral" | undefined;
             tokenCount?: number | undefined;
             truncated?: boolean | undefined;
             confidence?: number | undefined;
             vote?: string | undefined;
+            isAgent?: boolean | undefined;
         }[];
         summary?: string | undefined;
     }[];
@@ -995,6 +1419,22 @@ export declare const DiscussionResultSchema: z.ZodObject<{
         traceId?: string | undefined;
         totalTokens?: number | undefined;
         estimatedCost?: number | undefined;
+        costSummary?: {
+            totalTokens: number;
+            byProvider: Record<string, {
+                tokens: number;
+                cost: number;
+                calls: number;
+            }>;
+            totalCalls: number;
+            estimatedCostUsd: number;
+        } | undefined;
+        earlyExit?: {
+            triggered: boolean;
+            reason?: string | undefined;
+            atProviderCount?: number | undefined;
+            confidenceScore?: number | undefined;
+        } | undefined;
     };
     success: boolean;
     totalDurationMs: number;
@@ -1008,12 +1448,14 @@ export declare const DiscussionResultSchema: z.ZodObject<{
             content: string;
             provider: string;
             round: number;
+            agentId?: string | undefined;
             error?: string | undefined;
             role?: "moderator" | "proponent" | "opponent" | "judge" | "neutral" | undefined;
             tokenCount?: number | undefined;
             truncated?: boolean | undefined;
             confidence?: number | undefined;
             vote?: string | undefined;
+            isAgent?: boolean | undefined;
         }[];
         summary?: string | undefined;
     }[];
@@ -1116,8 +1558,236 @@ export declare const DiscussionErrorCodes: {
     readonly INVALID_CONFIG: "DISCUSSION_INVALID_CONFIG";
     /** Provider not found */
     readonly PROVIDER_NOT_FOUND: "DISCUSSION_PROVIDER_NOT_FOUND";
+    /** Maximum discussion depth exceeded */
+    readonly MAX_DEPTH_EXCEEDED: "DISCUSSION_MAX_DEPTH_EXCEEDED";
+    /** Circular discussion chain detected */
+    readonly CIRCULAR_DISCUSSION: "DISCUSSION_CIRCULAR_DISCUSSION";
+    /** Timeout budget exhausted */
+    readonly BUDGET_EXHAUSTED: "DISCUSSION_BUDGET_EXHAUSTED";
+    /** Maximum total calls exceeded */
+    readonly MAX_CALLS_EXCEEDED: "DISCUSSION_MAX_CALLS_EXCEEDED";
+    /** Cost budget exceeded */
+    readonly COST_BUDGET_EXCEEDED: "DISCUSSION_COST_BUDGET_EXCEEDED";
 };
 export type DiscussionErrorCode = (typeof DiscussionErrorCodes)[keyof typeof DiscussionErrorCodes];
+/**
+ * Timeout strategy for recursive discussions
+ *
+ * - fixed: Each level gets the same timeout
+ * - cascade: Each level gets reduced timeout (parent × 0.5)
+ * - budget: Total budget divided across levels
+ */
+export declare const TimeoutStrategySchema: z.ZodEnum<["fixed", "cascade", "budget"]>;
+export type TimeoutStrategy = z.infer<typeof TimeoutStrategySchema>;
+/**
+ * Timeout configuration for recursive discussions
+ *
+ * Invariants:
+ * - INV-DISC-610: Child timeout ≤ parent remaining budget
+ * - INV-DISC-611: Minimum time reserved for synthesis
+ * - INV-DISC-612: Total timeout includes all nested calls
+ */
+export declare const TimeoutConfigSchema: z.ZodObject<{
+    /** Timeout strategy */
+    strategy: z.ZodDefault<z.ZodEnum<["fixed", "cascade", "budget"]>>;
+    /** Total budget in milliseconds */
+    totalBudgetMs: z.ZodDefault<z.ZodNumber>;
+    /** Minimum time reserved for synthesis at each level */
+    minSynthesisMs: z.ZodDefault<z.ZodNumber>;
+    /** Override timeouts per level (optional) */
+    levelTimeouts: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodNumber>>;
+}, "strip", z.ZodTypeAny, {
+    strategy: "budget" | "fixed" | "cascade";
+    totalBudgetMs: number;
+    minSynthesisMs: number;
+    levelTimeouts?: Record<string, number> | undefined;
+}, {
+    strategy?: "budget" | "fixed" | "cascade" | undefined;
+    totalBudgetMs?: number | undefined;
+    minSynthesisMs?: number | undefined;
+    levelTimeouts?: Record<string, number> | undefined;
+}>;
+export type TimeoutConfig = z.infer<typeof TimeoutConfigSchema>;
+/**
+ * Cascading confidence configuration for early exit
+ *
+ * Invariants:
+ * - INV-DISC-622: Threshold configurable (default 0.9)
+ * - INV-DISC-623: Minimum 2 providers for quality
+ */
+export declare const CascadingConfidenceConfigSchema: z.ZodObject<{
+    /** Enable early exit when first provider is highly confident */
+    enabled: z.ZodDefault<z.ZodBoolean>;
+    /** Confidence threshold for early exit (0-1) */
+    threshold: z.ZodDefault<z.ZodNumber>;
+    /** Minimum providers to call regardless of confidence */
+    minProviders: z.ZodDefault<z.ZodNumber>;
+}, "strip", z.ZodTypeAny, {
+    enabled: boolean;
+    threshold: number;
+    minProviders: number;
+}, {
+    enabled?: boolean | undefined;
+    threshold?: number | undefined;
+    minProviders?: number | undefined;
+}>;
+export type CascadingConfidenceConfig = z.infer<typeof CascadingConfidenceConfigSchema>;
+/**
+ * Cost control configuration for recursive discussions
+ *
+ * Invariants:
+ * - INV-DISC-620: Total calls ≤ maxTotalCalls
+ * - INV-DISC-621: Abort if cost budget exceeded
+ */
+export declare const CostControlConfigSchema: z.ZodObject<{
+    /** Maximum total provider calls across all nested discussions */
+    maxTotalCalls: z.ZodDefault<z.ZodNumber>;
+    /** Optional hard cost limit in USD */
+    budgetUsd: z.ZodOptional<z.ZodNumber>;
+    /** Cascading confidence configuration */
+    cascadingConfidence: z.ZodDefault<z.ZodObject<{
+        /** Enable early exit when first provider is highly confident */
+        enabled: z.ZodDefault<z.ZodBoolean>;
+        /** Confidence threshold for early exit (0-1) */
+        threshold: z.ZodDefault<z.ZodNumber>;
+        /** Minimum providers to call regardless of confidence */
+        minProviders: z.ZodDefault<z.ZodNumber>;
+    }, "strip", z.ZodTypeAny, {
+        enabled: boolean;
+        threshold: number;
+        minProviders: number;
+    }, {
+        enabled?: boolean | undefined;
+        threshold?: number | undefined;
+        minProviders?: number | undefined;
+    }>>;
+}, "strip", z.ZodTypeAny, {
+    maxTotalCalls: number;
+    cascadingConfidence: {
+        enabled: boolean;
+        threshold: number;
+        minProviders: number;
+    };
+    budgetUsd?: number | undefined;
+}, {
+    maxTotalCalls?: number | undefined;
+    budgetUsd?: number | undefined;
+    cascadingConfidence?: {
+        enabled?: boolean | undefined;
+        threshold?: number | undefined;
+        minProviders?: number | undefined;
+    } | undefined;
+}>;
+export type CostControlConfig = z.infer<typeof CostControlConfigSchema>;
+/**
+ * Recursive discussion configuration
+ *
+ * Invariants:
+ * - INV-DISC-600: Depth MUST NOT exceed maxDepth
+ * - INV-DISC-601: No circular provider chains
+ * - INV-DISC-602: Root discussion is always depth 0
+ */
+export declare const RecursiveConfigSchema: z.ZodObject<{
+    /** Enable recursive sub-discussions */
+    enabled: z.ZodDefault<z.ZodBoolean>;
+    /** Maximum discussion depth (1-4) */
+    maxDepth: z.ZodDefault<z.ZodNumber>;
+    /** Providers allowed in sub-discussions (defaults to all) */
+    allowedProviders: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
+    /** Whether providers can spawn sub-discussions */
+    allowSubDiscussions: z.ZodDefault<z.ZodBoolean>;
+}, "strip", z.ZodTypeAny, {
+    enabled: boolean;
+    maxDepth: number;
+    allowSubDiscussions: boolean;
+    allowedProviders?: string[] | undefined;
+}, {
+    enabled?: boolean | undefined;
+    maxDepth?: number | undefined;
+    allowedProviders?: string[] | undefined;
+    allowSubDiscussions?: boolean | undefined;
+}>;
+export type RecursiveConfig = z.infer<typeof RecursiveConfigSchema>;
+/**
+ * Discussion context for tracking recursion state
+ *
+ * Invariants:
+ * - INV-DISC-600: depth < maxDepth for sub-discussions
+ * - INV-DISC-601: discussionChain has no duplicates
+ */
+export declare const DiscussionContextSchema: z.ZodObject<{
+    /** Current discussion depth (0 = root) */
+    depth: z.ZodDefault<z.ZodNumber>;
+    /** Maximum allowed depth */
+    maxDepth: z.ZodDefault<z.ZodNumber>;
+    /** Chain of discussion IDs (for circular detection) */
+    discussionChain: z.ZodDefault<z.ZodArray<z.ZodString, "many">>;
+    /** Parent discussion ID (undefined for root) */
+    parentDiscussionId: z.ZodOptional<z.ZodString>;
+    /** Root discussion ID */
+    rootDiscussionId: z.ZodString;
+    /** Remaining timeout budget in milliseconds */
+    remainingBudgetMs: z.ZodNumber;
+    /** Total provider calls made so far */
+    totalCalls: z.ZodDefault<z.ZodNumber>;
+    /** Maximum total calls allowed */
+    maxTotalCalls: z.ZodDefault<z.ZodNumber>;
+    /** When the root discussion started */
+    startedAt: z.ZodString;
+}, "strip", z.ZodTypeAny, {
+    startedAt: string;
+    maxDepth: number;
+    totalCalls: number;
+    maxTotalCalls: number;
+    depth: number;
+    discussionChain: string[];
+    rootDiscussionId: string;
+    remainingBudgetMs: number;
+    parentDiscussionId?: string | undefined;
+}, {
+    startedAt: string;
+    rootDiscussionId: string;
+    remainingBudgetMs: number;
+    maxDepth?: number | undefined;
+    totalCalls?: number | undefined;
+    maxTotalCalls?: number | undefined;
+    depth?: number | undefined;
+    discussionChain?: string[] | undefined;
+    parentDiscussionId?: string | undefined;
+}>;
+export type DiscussionContext = z.infer<typeof DiscussionContextSchema>;
+/**
+ * Sub-discussion result embedded in provider response
+ */
+export declare const SubDiscussionResultSchema: z.ZodObject<{
+    /** Sub-discussion ID */
+    discussionId: z.ZodString;
+    /** Topic of sub-discussion */
+    topic: z.ZodString;
+    /** Providers that participated */
+    participatingProviders: z.ZodArray<z.ZodString, "many">;
+    /** Synthesized result */
+    synthesis: z.ZodString;
+    /** Duration in milliseconds */
+    durationMs: z.ZodNumber;
+    /** Depth at which this occurred */
+    depth: z.ZodNumber;
+}, "strip", z.ZodTypeAny, {
+    durationMs: number;
+    topic: string;
+    participatingProviders: string[];
+    synthesis: string;
+    depth: number;
+    discussionId: string;
+}, {
+    durationMs: number;
+    topic: string;
+    participatingProviders: string[];
+    synthesis: string;
+    depth: number;
+    discussionId: string;
+}>;
+export type SubDiscussionResult = z.infer<typeof SubDiscussionResultSchema>;
 /**
  * Validates discussion step configuration
  * @throws ZodError if validation fails
@@ -1183,4 +1853,37 @@ export declare function createEmptyDiscussionResult(pattern: DiscussionPattern,
  * Creates a failed discussion result
  */
 export declare function createFailedDiscussionResult(pattern: DiscussionPattern, topic: string, errorCode: DiscussionErrorCode, errorMessage: string, startedAt: string): DiscussionResult;
+/**
+ * Creates a root discussion context
+ */
+export declare function createRootDiscussionContext(discussionId: string, config?: {
+    maxDepth?: number;
+    totalBudgetMs?: number;
+    maxTotalCalls?: number;
+}): DiscussionContext;
+/**
+ * Creates a child discussion context from a parent context
+ *
+ * @throws Error if max depth exceeded or circular discussion detected
+ */
+export declare function createChildDiscussionContext(parentContext: DiscussionContext, childDiscussionId: string, elapsedMs: number, callsMade: number): DiscussionContext;
+/**
+ * Check if sub-discussion is allowed given current context
+ */
+export declare function canSpawnSubDiscussion(context: DiscussionContext, minBudgetMs?: number): {
+    allowed: boolean;
+    reason?: string;
+};
+/**
+ * Calculate timeout for a given depth using cascade strategy
+ */
+export declare function calculateCascadeTimeout(totalBudgetMs: number, depth: number, minSynthesisMs?: number): number;
+/**
+ * Calculate timeout for a given depth using budget strategy
+ */
+export declare function calculateBudgetTimeout(totalBudgetMs: number, maxDepth: number, depth: number, minSynthesisMs?: number): number;
+/**
+ * Get timeout for a level based on strategy
+ */
+export declare function getTimeoutForLevel(config: TimeoutConfig, depth: number, maxDepth: number): number;
 //# sourceMappingURL=schema.d.ts.map