@clipboard-health/tribunal 1.1.0

package/src/schemas.d.ts

@@ -0,0 +1,165 @@
+import { z } from "zod";
+export declare const roleSchema: z.ZodEnum<["advocate", "skeptic", "analyst"]>;
+export declare const confidenceSchema: z.ZodNumber;
+export declare const claimSchema: z.ZodObject<{
+    claim: z.ZodString;
+    confidence: z.ZodNumber;
+    reasoning: z.ZodString;
+} & {
+    assumptions: z.ZodDefault<z.ZodArray<z.ZodString, "many">>;
+}, "strip", z.ZodTypeAny, {
+    claim: string;
+    confidence: number;
+    reasoning: string;
+    assumptions: string[];
+}, {
+    claim: string;
+    confidence: number;
+    reasoning: string;
+    assumptions?: string[] | undefined;
+}>;
+export declare const generatedPerspectiveResultSchema: z.ZodObject<{
+    role: z.ZodEnum<["advocate", "skeptic", "analyst"]>;
+    summary: z.ZodString;
+    claims: z.ZodArray<z.ZodObject<{
+        claim: z.ZodString;
+        confidence: z.ZodNumber;
+        reasoning: z.ZodString;
+        assumptions: z.ZodArray<z.ZodString, "many">;
+    }, "strip", z.ZodTypeAny, {
+        claim: string;
+        confidence: number;
+        reasoning: string;
+        assumptions: string[];
+    }, {
+        claim: string;
+        confidence: number;
+        reasoning: string;
+        assumptions: string[];
+    }>, "many">;
+    openQuestions: z.ZodArray<z.ZodString, "many">;
+}, "strip", z.ZodTypeAny, {
+    role: "advocate" | "analyst" | "skeptic";
+    summary: string;
+    claims: {
+        claim: string;
+        confidence: number;
+        reasoning: string;
+        assumptions: string[];
+    }[];
+    openQuestions: string[];
+}, {
+    role: "advocate" | "analyst" | "skeptic";
+    summary: string;
+    claims: {
+        claim: string;
+        confidence: number;
+        reasoning: string;
+        assumptions: string[];
+    }[];
+    openQuestions: string[];
+}>;
+export declare const perspectiveResultSchema: z.ZodObject<{
+    role: z.ZodEnum<["advocate", "skeptic", "analyst"]>;
+    summary: z.ZodString;
+} & {
+    claims: z.ZodArray<z.ZodObject<{
+        claim: z.ZodString;
+        confidence: z.ZodNumber;
+        reasoning: z.ZodString;
+    } & {
+        assumptions: z.ZodDefault<z.ZodArray<z.ZodString, "many">>;
+    }, "strip", z.ZodTypeAny, {
+        claim: string;
+        confidence: number;
+        reasoning: string;
+        assumptions: string[];
+    }, {
+        claim: string;
+        confidence: number;
+        reasoning: string;
+        assumptions?: string[] | undefined;
+    }>, "many">;
+    openQuestions: z.ZodDefault<z.ZodArray<z.ZodString, "many">>;
+}, "strip", z.ZodTypeAny, {
+    role: "advocate" | "analyst" | "skeptic";
+    summary: string;
+    claims: {
+        claim: string;
+        confidence: number;
+        reasoning: string;
+        assumptions: string[];
+    }[];
+    openQuestions: string[];
+}, {
+    role: "advocate" | "analyst" | "skeptic";
+    summary: string;
+    claims: {
+        claim: string;
+        confidence: number;
+        reasoning: string;
+        assumptions?: string[] | undefined;
+    }[];
+    openQuestions?: string[] | undefined;
+}>;
+export declare const generatedDeliberationResultSchema: z.ZodObject<{
+    answer: z.ZodString;
+    keyTakeaways: z.ZodArray<z.ZodString, "many">;
+    consensus: z.ZodArray<z.ZodString, "many">;
+    disagreements: z.ZodArray<z.ZodString, "many">;
+    recommendation: z.ZodNullable<z.ZodString>;
+    confidence: z.ZodNumber;
+    caveats: z.ZodArray<z.ZodString, "many">;
+    openQuestions: z.ZodArray<z.ZodString, "many">;
+}, "strip", z.ZodTypeAny, {
+    answer: string;
+    keyTakeaways: string[];
+    consensus: string[];
+    disagreements: string[];
+    recommendation: string | null;
+    confidence: number;
+    caveats: string[];
+    openQuestions: string[];
+}, {
+    answer: string;
+    keyTakeaways: string[];
+    consensus: string[];
+    disagreements: string[];
+    recommendation: string | null;
+    confidence: number;
+    caveats: string[];
+    openQuestions: string[];
+}>;
+export declare const deliberationResultSchema: z.ZodObject<{
+    answer: z.ZodString;
+    keyTakeaways: z.ZodArray<z.ZodString, "many">;
+    recommendation: z.ZodNullable<z.ZodString>;
+    confidence: z.ZodNumber;
+} & {
+    consensus: z.ZodDefault<z.ZodArray<z.ZodString, "many">>;
+    disagreements: z.ZodDefault<z.ZodArray<z.ZodString, "many">>;
+    caveats: z.ZodDefault<z.ZodArray<z.ZodString, "many">>;
+    openQuestions: z.ZodDefault<z.ZodArray<z.ZodString, "many">>;
+}, "strip", z.ZodTypeAny, {
+    answer: string;
+    keyTakeaways: string[];
+    recommendation: string | null;
+    confidence: number;
+    consensus: string[];
+    disagreements: string[];
+    caveats: string[];
+    openQuestions: string[];
+}, {
+    answer: string;
+    keyTakeaways: string[];
+    recommendation: string | null;
+    confidence: number;
+    consensus?: string[] | undefined;
+    disagreements?: string[] | undefined;
+    caveats?: string[] | undefined;
+    openQuestions?: string[] | undefined;
+}>;
+export type Role = z.infer<typeof roleSchema>;
+export type Claim = z.infer<typeof claimSchema>;
+export type PerspectiveResult = z.infer<typeof perspectiveResultSchema>;
+export type DeliberationResult = z.infer<typeof deliberationResultSchema>;

package/src/schemas.js

@@ -0,0 +1,39 @@
+import { z } from "zod";
+export const roleSchema = z.enum(["advocate", "skeptic", "analyst"]);
+export const confidenceSchema = z.number().min(0).max(1);
+const generatedClaimSchema = z.object({
+    claim: z.string(),
+    confidence: confidenceSchema,
+    reasoning: z.string(),
+    assumptions: z.array(z.string()),
+});
+export const claimSchema = generatedClaimSchema.extend({
+    assumptions: z.array(z.string()).default([]),
+});
+export const generatedPerspectiveResultSchema = z.object({
+    role: roleSchema,
+    summary: z.string(),
+    claims: z.array(generatedClaimSchema).min(1).max(5),
+    openQuestions: z.array(z.string()),
+});
+export const perspectiveResultSchema = generatedPerspectiveResultSchema.extend({
+    claims: z.array(claimSchema).min(1).max(5),
+    openQuestions: z.array(z.string()).default([]),
+});
+export const generatedDeliberationResultSchema = z.object({
+    answer: z.string(),
+    keyTakeaways: z.array(z.string()).min(1).max(7),
+    consensus: z.array(z.string()),
+    disagreements: z.array(z.string()),
+    recommendation: z.string().nullable(),
+    confidence: confidenceSchema,
+    caveats: z.array(z.string()),
+    openQuestions: z.array(z.string()),
+});
+export const deliberationResultSchema = generatedDeliberationResultSchema.extend({
+    consensus: z.array(z.string()).default([]),
+    disagreements: z.array(z.string()).default([]),
+    caveats: z.array(z.string()).default([]),
+    openQuestions: z.array(z.string()).default([]),
+});
+//# sourceMappingURL=schemas.js.map

package/src/schemas.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"schemas.js","sourceRoot":"","sources":["../../../../packages/tribunal/src/schemas.ts"],"names":[],"mappings":"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"}

package/src/tribunal.d.ts

@@ -0,0 +1,95 @@
+import { type LanguageModelUsage } from "ai";
+import type { z } from "zod";
+import { type ModelRole, type ModelSpec } from "./models.ts";
+import { type ReasoningLevel, type ReasoningOverrides } from "./reasoning.ts";
+import { type DeliberationResult, type PerspectiveResult, type Role } from "./schemas.ts";
+export type OutputFormat = "text" | "json" | "markdown";
+export interface TribunalRequest {
+    query: string;
+    context?: string;
+    models?: Partial<Record<ModelRole, ModelSpec>>;
+    reasoning?: ReasoningOverrides;
+    showPerspectives?: boolean;
+}
+export interface TokenUsage {
+    inputTokens?: number;
+    outputTokens?: number;
+    totalTokens?: number;
+}
+export interface CallMetadata {
+    model: ModelSpec;
+    latencyMs: number;
+    usage?: TokenUsage;
+}
+export interface PerspectiveOutput {
+    role: Role;
+    result: PerspectiveResult;
+    metadata: CallMetadata;
+}
+export interface TribunalResponse {
+    result: DeliberationResult;
+    perspectives: PerspectiveOutput[];
+    metadata: {
+        models: Record<ModelRole, ModelSpec>;
+        reasoning?: ReasoningOverrides;
+        totalUsage?: TokenUsage;
+        estimatedCostUsd: number | null;
+        latencyMs: number;
+        warnings: string[];
+    };
+}
+export type TribunalProgressStatus = "started" | "completed" | "failed";
+export interface TribunalProgressEvent {
+    role: ModelRole;
+    status: TribunalProgressStatus;
+    model: ModelSpec;
+    latencyMs?: number;
+    metadata?: CallMetadata;
+    output?: unknown;
+    errorMessage?: string;
+}
+export type TribunalProgressHandler = (event: TribunalProgressEvent) => void | Promise<void>;
+interface StructuredOutputRunnerInput {
+    role: ModelRole;
+    reasoningLevel?: ReasoningLevel | undefined;
+    model: ModelSpec;
+    system: string;
+    prompt: string;
+    schema: z.ZodType;
+}
+interface StructuredOutputRunnerResult {
+    output: unknown;
+    metadata: CallMetadata;
+}
+export type StructuredOutputRunner = (input: StructuredOutputRunnerInput) => Promise<StructuredOutputRunnerResult>;
+interface RunTribunalOptions {
+    environment?: Record<string, string | undefined>;
+    structuredOutputRunner?: StructuredOutputRunner;
+    onProgress?: TribunalProgressHandler;
+    now?: () => number;
+}
+export interface StructuredOutputInput<T> {
+    model: ModelSpec;
+    reasoningLevel?: ReasoningLevel | undefined;
+    system: string;
+    prompt: string;
+    schema: z.ZodType<T>;
+}
+export interface StructuredOutputResult<T> {
+    output: T;
+    metadata: CallMetadata;
+}
+export interface CostEstimateCall {
+    role: ModelRole;
+    metadata: CallMetadata;
+}
+export interface CostEstimate {
+    estimatedCostUsd: number | null;
+    warning?: string;
+}
+export declare function runTribunal(request: TribunalRequest, options?: RunTribunalOptions): Promise<TribunalResponse>;
+export declare function runStructuredOutput<T>(input: StructuredOutputInput<T>): Promise<StructuredOutputResult<T>>;
+export declare function normalizeUsage(usage: LanguageModelUsage): TokenUsage;
+export declare function sumTokenUsage(usages: TokenUsage[]): TokenUsage | undefined;
+export declare function estimateCostUsd(calls: CostEstimateCall[]): CostEstimate;
+export {};

package/src/tribunal.js

@@ -0,0 +1,383 @@
+import { generateText, Output } from "ai";
+import { formatModelSpec, resolveLanguageModel, resolveModelSet, } from "./models.js";
+import { createReasoningProviderOptions, } from "./reasoning.js";
+import { deliberationResultSchema, generatedDeliberationResultSchema, generatedPerspectiveResultSchema, perspectiveResultSchema, } from "./schemas.js";
+const MAX_WARNINGS_TO_LIST = 3;
+const DEFAULT_PERSPECTIVES = [
+    {
+        role: "advocate",
+        system: "Argue the strongest reasonable case FOR the proposal. Focus on benefits, upside, why it could work, and what would need to be true.",
+    },
+    {
+        role: "skeptic",
+        system: "Argue the strongest reasonable case AGAINST the proposal. Focus on risks, hidden costs, failure modes, and reasons it may not work.",
+    },
+    {
+        role: "analyst",
+        system: "Analyze the proposal neutrally. Map the decision space, tradeoffs, criteria, dependencies, and unknowns without taking a side.",
+    },
+];
+const DELIBERATOR_SYSTEM_PROMPT = `You are a deliberator comparing multiple structured perspectives.
+
+Evaluate claims on their merits, not based on model/provider identity.
+Identify true consensus, important disagreements, assumptions, and decision criteria.
+Do not simply summarize each perspective.
+Produce a balanced answer with a clear recommendation when the evidence supports one.
+If the answer depends on missing information, say what information would change the recommendation.`;
+const MODEL_PRICING_USD_PER_1M_TOKENS = {};
+export async function runTribunal(request, options = {}) {
+    const now = options.now ?? performance.now.bind(performance);
+    const start = now();
+    const structuredOutputRunner = options.structuredOutputRunner ?? defaultStructuredOutputRunner;
+    const models = resolveModelSet(createResolveModelSetInput(options.environment, request.models));
+    const reasoning = copyReasoningOverrides(request.reasoning);
+    const warnings = [];
+    const prompt = buildQuestionPrompt(createPromptInput(request.query, request.context));
+    const settledPerspectives = await Promise.allSettled(DEFAULT_PERSPECTIVES.map(async (perspective) => await runPerspective({
+        model: models[perspective.role],
+        onProgress: options.onProgress,
+        perspective,
+        prompt,
+        reasoningLevel: reasoning?.[perspective.role],
+        structuredOutputRunner,
+    })));
+    const perspectives = collectSuccessfulPerspectives(settledPerspectives, warnings);
+    if (perspectives.length < 2) {
+        throw new Error(`At least two perspectives must succeed before deliberation. Received ${perspectives.length}.`);
+    }
+    const deliberation = await runStructuredOutputWithProgress({
+        model: models.deliberator,
+        onProgress: options.onProgress,
+        prompt: buildDeliberatorPrompt(createDeliberatorPromptInput(request.query, request.context, perspectives)),
+        reasoningLevel: reasoning?.deliberator,
+        role: "deliberator",
+        schema: generatedDeliberationResultSchema,
+        structuredOutputRunner,
+        system: DELIBERATOR_SYSTEM_PROMPT,
+    });
+    const result = deliberationResultSchema.parse(deliberation.output);
+    const allCalls = [
+        ...perspectives.map((perspective) => ({
+            metadata: perspective.metadata,
+            role: perspective.role,
+        })),
+        { metadata: deliberation.metadata, role: "deliberator" },
+    ];
+    const costEstimate = estimateCostUsd(allCalls);
+    if (costEstimate.warning !== undefined) {
+        warnings.push(costEstimate.warning);
+    }
+    const totalUsage = sumTokenUsage(allCalls.map((call) => call.metadata.usage ?? {}));
+    const metadata = {
+        models,
+        estimatedCostUsd: costEstimate.estimatedCostUsd,
+        latencyMs: Math.round(now() - start),
+        warnings,
+    };
+    if (reasoning !== undefined) {
+        metadata.reasoning = reasoning;
+    }
+    if (totalUsage !== undefined) {
+        metadata.totalUsage = totalUsage;
+    }
+    return {
+        result,
+        perspectives,
+        metadata,
+    };
+}
+export async function runStructuredOutput(input) {
+    const { model, prompt, reasoningLevel, schema, system } = input;
+    const start = performance.now();
+    const providerOptions = createReasoningProviderOptions({ model, reasoningLevel });
+    const result = await generateText({
+        model: resolveLanguageModel(model),
+        output: Output.object({ schema }),
+        prompt,
+        ...(providerOptions === undefined ? {} : { providerOptions }),
+        system,
+    });
+    return {
+        output: result.output,
+        metadata: {
+            model,
+            latencyMs: Math.round(performance.now() - start),
+            usage: normalizeUsage(result.usage),
+        },
+    };
+}
+export function normalizeUsage(usage) {
+    const normalizedUsage = {};
+    assignTokenUsage(normalizedUsage, "inputTokens", usage.inputTokens);
+    assignTokenUsage(normalizedUsage, "outputTokens", usage.outputTokens);
+    assignTokenUsage(normalizedUsage, "totalTokens", usage.totalTokens);
+    return normalizedUsage;
+}
+export function sumTokenUsage(usages) {
+    let inputTokens = 0;
+    let outputTokens = 0;
+    let totalTokens = 0;
+    let hasInputTokens = false;
+    let hasOutputTokens = false;
+    let hasTotalTokens = false;
+    for (const usage of usages) {
+        if (usage.inputTokens !== undefined) {
+            inputTokens += usage.inputTokens;
+            hasInputTokens = true;
+        }
+        if (usage.outputTokens !== undefined) {
+            outputTokens += usage.outputTokens;
+            hasOutputTokens = true;
+        }
+        if (usage.totalTokens !== undefined) {
+            totalTokens += usage.totalTokens;
+            hasTotalTokens = true;
+        }
+    }
+    if (!hasInputTokens && !hasOutputTokens && !hasTotalTokens) {
+        return undefined;
+    }
+    return {
+        ...(hasInputTokens ? { inputTokens } : {}),
+        ...(hasOutputTokens ? { outputTokens } : {}),
+        ...(hasTotalTokens ? { totalTokens } : {}),
+    };
+}
+function assignTokenUsage(usage, key, value) {
+    if (value === undefined) {
+        return;
+    }
+    usage[key] = value;
+}
+function createResolveModelSetInput(environment, overrides) {
+    const input = {
+        environment: environment ?? getProcessEnvironment(),
+    };
+    if (overrides === undefined) {
+        return input;
+    }
+    input.overrides = overrides;
+    return input;
+}
+function getProcessEnvironment() {
+    // oxlint-disable-next-line node/no-process-env -- Centralized fallback so direct runTribunal calls can read op-run-injected model override vars.
+    return process.env;
+}
+function createPromptInput(query, context) {
+    if (context === undefined) {
+        return { query };
+    }
+    return { query, context };
+}
+function createDeliberatorPromptInput(query, context, perspectives) {
+    if (context === undefined) {
+        return { query, perspectives };
+    }
+    return { query, context, perspectives };
+}
+export function estimateCostUsd(calls) {
+    const modelsWithUnknownPricing = new Set();
+    for (const call of calls) {
+        const modelKey = formatModelSpec(call.metadata.model);
+        const pricing = MODEL_PRICING_USD_PER_1M_TOKENS[modelKey];
+        if (pricing === undefined) {
+            modelsWithUnknownPricing.add(modelKey);
+        }
+    }
+    if (modelsWithUnknownPricing.size > 0) {
+        return {
+            estimatedCostUsd: null,
+            warning: `Cost estimate unavailable because pricing is unknown for ${formatLimitedList([
+                ...modelsWithUnknownPricing,
+            ])}.`,
+        };
+    }
+    let estimatedCostUsd = 0;
+    for (const call of calls) {
+        const { metadata: { usage }, } = call;
+        if (usage?.inputTokens === undefined || usage.outputTokens === undefined) {
+            return {
+                estimatedCostUsd: null,
+                warning: "Cost estimate unavailable because token usage was not returned.",
+            };
+        }
+        const pricing = MODEL_PRICING_USD_PER_1M_TOKENS[formatModelSpec(call.metadata.model)];
+        if (pricing === undefined) {
+            return {
+                estimatedCostUsd: null,
+                warning: "Cost estimate unavailable because model pricing changed during calculation.",
+            };
+        }
+        estimatedCostUsd +=
+            (usage.inputTokens / 1_000_000) * pricing.inputUsdPerMillionTokens +
+                (usage.outputTokens / 1_000_000) * pricing.outputUsdPerMillionTokens;
+    }
+    return { estimatedCostUsd };
+}
+async function defaultStructuredOutputRunner(input) {
+    const { model, prompt, reasoningLevel, schema, system } = input;
+    return await runStructuredOutput({ model, prompt, reasoningLevel, schema, system });
+}
+async function runPerspective(input) {
+    const { model, onProgress, perspective, prompt, reasoningLevel, structuredOutputRunner } = input;
+    const output = await runStructuredOutputWithProgress({
+        model,
+        onProgress,
+        prompt,
+        reasoningLevel,
+        role: perspective.role,
+        schema: generatedPerspectiveResultSchema,
+        structuredOutputRunner,
+        system: perspective.system,
+    });
+    const result = perspectiveResultSchema.parse(output.output);
+    if (result.role !== perspective.role) {
+        throw new Error(`Perspective role mismatch: expected ${perspective.role}, received ${result.role}.`);
+    }
+    return {
+        role: perspective.role,
+        result,
+        metadata: output.metadata,
+    };
+}
+async function runStructuredOutputWithProgress(input) {
+    const { model, onProgress, prompt, reasoningLevel, role, schema, structuredOutputRunner, system, } = input;
+    const runnerInput = {
+        model,
+        prompt,
+        reasoningLevel,
+        role,
+        schema,
+        system,
+    };
+    await emitProgress(onProgress, { model, role, status: "started" });
+    try {
+        const output = await structuredOutputRunner(runnerInput);
+        await emitProgress(onProgress, {
+            latencyMs: output.metadata.latencyMs,
+            metadata: output.metadata,
+            model,
+            output: output.output,
+            role,
+            status: "completed",
+        });
+        return output;
+    }
+    catch (error) {
+        await emitProgress(onProgress, {
+            errorMessage: formatErrorMessage(error),
+            model,
+            role,
+            status: "failed",
+        });
+        throw error;
+    }
+}
+async function emitProgress(onProgress, event) {
+    if (onProgress === undefined) {
+        return;
+    }
+    try {
+        await onProgress(event);
+    }
+    catch {
+        // Progress hooks are best-effort; recorder or logger failures must not abort model calls.
+    }
+}
+function collectSuccessfulPerspectives(settledPerspectives, warnings) {
+    const perspectives = [];
+    for (const [index, settledPerspective] of settledPerspectives.entries()) {
+        const perspective = DEFAULT_PERSPECTIVES[index];
+        if (settledPerspective === undefined || perspective === undefined) {
+            continue;
+        }
+        if (settledPerspective.status === "fulfilled") {
+            perspectives.push(settledPerspective.value);
+            continue;
+        }
+        warnings.push(`${perspective.role} perspective failed: ${formatErrorMessage(settledPerspective.reason)}`);
+    }
+    return perspectives;
+}
+function buildQuestionPrompt(input) {
+    const { context, query } = input;
+    if (context === undefined || context.trim().length === 0) {
+        return `Question:
+${query}
+
+Context:
+No additional context provided.`;
+    }
+    return `Question:
+${query}
+
+Context:
+${context}`;
+}
+function buildDeliberatorPrompt(input) {
+    const { context, perspectives, query } = input;
+    const contextText = context === undefined || context.trim().length === 0
+        ? "No additional context provided."
+        : context;
+    return `Question:
+${query}
+
+Context:
+${contextText}
+
+Perspectives:
+${perspectives.map(formatPerspectiveForDeliberator).join("\n\n")}`;
+}
+function formatPerspectiveForDeliberator(perspective) {
+    const claims = perspective.result.claims
+        .map((claim) => `  - ${claim.claim} (confidence ${formatConfidence(claim.confidence)}): ${claim.reasoning}`)
+        .join("\n");
+    const openQuestions = perspective.result.openQuestions.length === 0
+        ? "  - none"
+        : perspective.result.openQuestions.map((question) => `  - ${question}`).join("\n");
+    return `- ${perspective.role}: ${perspective.result.summary}
+  Claims:
+${claims}
+  Open questions:
+${openQuestions}`;
+}
+function formatConfidence(confidence) {
+    return `${Math.round(confidence * 100)}%`;
+}
+function formatErrorMessage(error) {
+    return error instanceof Error ? error.message : String(error);
+}
+function formatLimitedList(items) {
+    const sortedItems = items.toSorted();
+    const displayedItems = sortedItems.slice(0, MAX_WARNINGS_TO_LIST);
+    const remainingCount = sortedItems.length - displayedItems.length;
+    if (remainingCount === 0) {
+        return displayedItems.join(", ");
+    }
+    return `${displayedItems.join(", ")} and ${remainingCount} more`;
+}
+function copyReasoningOverrides(overrides) {
+    if (overrides === undefined) {
+        return undefined;
+    }
+    const copiedOverrides = {};
+    copyReasoningOverride(copiedOverrides, overrides, "advocate");
+    copyReasoningOverride(copiedOverrides, overrides, "skeptic");
+    copyReasoningOverride(copiedOverrides, overrides, "analyst");
+    copyReasoningOverride(copiedOverrides, overrides, "deliberator");
+    if (copiedOverrides.advocate === undefined &&
+        copiedOverrides.skeptic === undefined &&
+        copiedOverrides.analyst === undefined &&
+        copiedOverrides.deliberator === undefined) {
+        return undefined;
+    }
+    return copiedOverrides;
+}
+function copyReasoningOverride(target, source, role) {
+    const level = source[role];
+    if (level === undefined) {
+        return;
+    }
+    target[role] = level;
+}
+//# sourceMappingURL=tribunal.js.map