dsh-model-jury 0.1.0

package/lib/protocol/schemas.d.ts

@@ -0,0 +1,66 @@
+import { z } from 'zod';
+/** Validated blind-position output. */
+export declare const Round1Schema: z.ZodObject<{
+    thesis: z.ZodString;
+    recommendation: z.ZodString;
+    reasoning: z.ZodArray<z.ZodString>;
+    assumptions: z.ZodArray<z.ZodString>;
+    risks: z.ZodArray<z.ZodString>;
+    evidence_needed: z.ZodArray<z.ZodString>;
+    confidence: z.ZodNumber;
+}, z.core.$strip>;
+/** Validated anonymous cross-critique output. */
+export declare const Round2Schema: z.ZodObject<{
+    critiques: z.ZodArray<z.ZodObject<{
+        target: z.ZodEnum<{
+            P1: "P1";
+            P2: "P2";
+            P3: "P3";
+        }>;
+        strongest_point: z.ZodString;
+        weakest_point: z.ZodString;
+        possible_error: z.ZodString;
+        missing_evidence: z.ZodString;
+        severity: z.ZodEnum<{
+            low: "low";
+            medium: "medium";
+            high: "high";
+            critical: "critical";
+        }>;
+    }, z.core.$strip>>;
+    preferred_position: z.ZodEnum<{
+        P1: "P1";
+        P2: "P2";
+        P3: "P3";
+        hybrid: "hybrid";
+        undecided: "undecided";
+    }>;
+    reason: z.ZodString;
+    confidence: z.ZodNumber;
+}, z.core.$strip>;
+/** Validated final revision output. */
+export declare const Round3Schema: z.ZodObject<{
+    final_recommendation: z.ZodString;
+    preferred_position: z.ZodEnum<{
+        P1: "P1";
+        P2: "P2";
+        P3: "P3";
+        hybrid: "hybrid";
+        undecided: "undecided";
+    }>;
+    changed_mind: z.ZodBoolean;
+    change_reason: z.ZodString;
+    agreement_points: z.ZodArray<z.ZodString>;
+    disagreement_points: z.ZodArray<z.ZodString>;
+    critical_risk: z.ZodObject<{
+        active: z.ZodBoolean;
+        category: z.ZodNullable<z.ZodString>;
+        reason: z.ZodNullable<z.ZodString>;
+    }, z.core.$strip>;
+    confidence: z.ZodNumber;
+}, z.core.$strip>;
+export type Round1Response = z.infer<typeof Round1Schema>;
+export type Round2Response = z.infer<typeof Round2Schema>;
+export type Round3Response = z.infer<typeof Round3Schema>;
+export type PreferredPosition = Round3Response['preferred_position'];
+//# sourceMappingURL=schemas.d.ts.map

package/lib/protocol/schemas.js

@@ -0,0 +1,48 @@
+import { z } from 'zod';
+const confidence = z.number().int().min(0).max(100);
+const nonEmpty = z.string().min(1);
+const preferredPosition = z.enum(['P1', 'P2', 'P3', 'hybrid', 'undecided']);
+/** Validated blind-position output. */
+export const Round1Schema = z.object({
+    thesis: nonEmpty,
+    recommendation: nonEmpty,
+    reasoning: z.array(nonEmpty),
+    assumptions: z.array(nonEmpty),
+    risks: z.array(nonEmpty),
+    evidence_needed: z.array(nonEmpty),
+    confidence,
+});
+/** Validated anonymous cross-critique output. */
+export const Round2Schema = z.object({
+    critiques: z.array(z.object({
+        target: z.enum(['P1', 'P2', 'P3']),
+        strongest_point: nonEmpty,
+        weakest_point: nonEmpty,
+        possible_error: nonEmpty,
+        missing_evidence: nonEmpty,
+        severity: z.enum(['low', 'medium', 'high', 'critical']),
+    })),
+    preferred_position: preferredPosition,
+    reason: nonEmpty,
+    confidence,
+});
+/** Validated final revision output. */
+export const Round3Schema = z.object({
+    final_recommendation: nonEmpty,
+    preferred_position: preferredPosition,
+    changed_mind: z.boolean(),
+    change_reason: nonEmpty,
+    agreement_points: z.array(nonEmpty),
+    disagreement_points: z.array(nonEmpty),
+    critical_risk: z.object({
+        active: z.boolean(),
+        category: z.string().min(1).nullable(),
+        reason: z.string().min(1).nullable(),
+    }).superRefine((risk, context) => {
+        if (risk.active && (risk.category === null || risk.reason === null)) {
+            context.addIssue({ code: 'custom', message: 'an active critical risk needs category and reason' });
+        }
+    }),
+    confidence,
+});
+//# sourceMappingURL=schemas.js.map

package/lib/protocol/state-machine.d.ts

@@ -0,0 +1,41 @@
+import type { Agent } from '@deepseek-ai/dsh-agent';
+import type { CouncilSeat, CouncilSeatId, CouncilSeatResponse, SeatCallMetadata } from '../seats/types.js';
+import { type AnonymizationMap, type RedistributionMetadata } from './anonymize.js';
+import { type CouncilFailure, type CouncilVerdict } from './aggregate.js';
+import { type CouncilStyle } from './prompts.js';
+import { type Round1Response, type Round2Response, type Round3Response } from './schemas.js';
+/** Ordered deterministic protocol phases. */
+export type CouncilState = 'idle' | 'round1' | 'anonymized' | 'round2' | 'round3' | 'aggregated' | 'completed';
+/** Observer used by persistence and tests without coupling protocol logic to storage. */
+export interface CouncilRunObserver {
+    stateChanged?(state: CouncilState): Promise<void> | void;
+    prompt?(round: 'round1' | 'round2' | 'round3', seat: CouncilSeatId, prompt: string): Promise<void> | void;
+    response?<T>(round: 'round1' | 'round2' | 'round3', seat: CouncilSeatId, response: CouncilSeatResponse<T>): Promise<void> | void;
+    failure?(failure: CouncilFailure, metadata?: SeatCallMetadata): Promise<void> | void;
+    redistribution?(metadata: Readonly<Record<string, RedistributionMetadata>>): Promise<void> | void;
+}
+/** Complete structured output of the deterministic protocol. */
+export interface CouncilRunResult {
+    readonly question: string;
+    readonly style: CouncilStyle;
+    readonly mapping: AnonymizationMap;
+    readonly round1: ReadonlyMap<CouncilSeatId, CouncilSeatResponse<Round1Response>>;
+    readonly round2: ReadonlyMap<CouncilSeatId, CouncilSeatResponse<Round2Response>>;
+    readonly round3: ReadonlyMap<CouncilSeatId, CouncilSeatResponse<Round3Response>>;
+    readonly failures: readonly CouncilFailure[];
+    readonly verdict: CouncilVerdict;
+}
+/** Code-owned three-round Council state machine. */
+export declare class CouncilStateMachine {
+    private readonly seats;
+    private readonly maxFieldChars;
+    private readonly observer;
+    private readonly createMapping;
+    private state;
+    constructor(seats: readonly CouncilSeat[], maxFieldChars: number, observer?: CouncilRunObserver, createMapping?: () => AnonymizationMap);
+    private transition;
+    private invokeRound;
+    /** Run blind positions, anonymous critique, revision, and deterministic aggregation. */
+    run(question: string, style: CouncilStyle, parent: Agent, signal: AbortSignal): Promise<CouncilRunResult>;
+}
+//# sourceMappingURL=state-machine.d.ts.map

package/lib/protocol/state-machine.js

@@ -0,0 +1,109 @@
+import { SEAT_NAMES, SeatInvocationError } from '../seats/types.js';
+import { createAnonymizationMap, sanitizeForRedistribution, } from './anonymize.js';
+import { aggregateCouncil } from './aggregate.js';
+import { round1Prompt, round2Prompt, round3Prompt } from './prompts.js';
+import { Round1Schema, Round2Schema, Round3Schema, } from './schemas.js';
+function errorText(error) {
+    return error instanceof Error ? error.message : String(error);
+}
+function callMetadata(error) {
+    return error instanceof SeatInvocationError ? error.metadata : undefined;
+}
+function identityTerms(seats) {
+    return [
+        'GPT', 'GLM', 'DeepSeek', 'Codex', 'OpenAI', 'Zhipu', 'ZhipuAI', 'BigModel',
+        ...seats.flatMap(seat => [seat.id, SEAT_NAMES[seat.id], seat.provider, seat.model ?? '']),
+    ];
+}
+function responseMap(responses) {
+    return new Map([...responses].map(([seat, response]) => [seat, response.value]));
+}
+/** Code-owned three-round Council state machine. */
+export class CouncilStateMachine {
+    seats;
+    maxFieldChars;
+    observer;
+    createMapping;
+    state = 'idle';
+    constructor(seats, maxFieldChars, observer = {}, createMapping = createAnonymizationMap) {
+        this.seats = seats;
+        this.maxFieldChars = maxFieldChars;
+        this.observer = observer;
+        this.createMapping = createMapping;
+        const ids = new Set(seats.map(seat => seat.id));
+        if (seats.length !== 3 || ids.size !== 3)
+            throw new Error('Council needs exactly one GPT, GLM, and DeepSeek seat');
+    }
+    async transition(expected, next) {
+        if (this.state !== expected)
+            throw new Error(`invalid Council transition ${this.state} -> ${next}`);
+        this.state = next;
+        await this.observer.stateChanged?.(next);
+    }
+    async invokeRound(round, schemaName, schema, promptFor, parent, signal, failures) {
+        const calls = this.seats.map(async (seat) => {
+            const prompt = promptFor(seat);
+            if (prompt === undefined)
+                return;
+            await this.observer.prompt?.(round, seat.id, prompt);
+            try {
+                const response = await seat.invoke({ round, prompt, schema, schemaName }, parent, signal);
+                await this.observer.response?.(round, seat.id, response);
+                return [seat.id, response];
+            }
+            catch (error) {
+                const failure = { seat: seat.id, round, error: errorText(error) };
+                failures.push(failure);
+                await this.observer.failure?.(failure, callMetadata(error));
+                return undefined;
+            }
+        });
+        const settled = await Promise.all(calls);
+        signal.throwIfAborted();
+        return new Map(settled.filter((entry) => entry !== undefined));
+    }
+    /** Run blind positions, anonymous critique, revision, and deterministic aggregation. */
+    async run(question, style, parent, signal) {
+        const failures = [];
+        const identities = identityTerms(this.seats);
+        await this.transition('idle', 'round1');
+        const firstPrompt = round1Prompt(question);
+        const round1 = await this.invokeRound('round1', 'Round1', Round1Schema, () => firstPrompt, parent, signal, failures);
+        await this.transition('round1', 'anonymized');
+        const mapping = this.createMapping();
+        const sanitizedRound1 = new Map();
+        const redistribution = {};
+        for (const [seat, response] of round1) {
+            const sanitized = sanitizeForRedistribution(response.value, this.maxFieldChars, identities);
+            sanitizedRound1.set(seat, sanitized.value);
+            redistribution[`round1.${seat}`] = sanitized.metadata;
+        }
+        const positionEntries = [...sanitizedRound1].map(([seat, value]) => [
+            mapping[seat],
+            value,
+        ]);
+        positionEntries.sort((left, right) => left[0].localeCompare(right[0]));
+        const positions = Object.fromEntries(positionEntries);
+        await this.observer.redistribution?.(redistribution);
+        await this.transition('anonymized', 'round2');
+        const round2 = await this.invokeRound('round2', 'Round2', Round2Schema, seat => sanitizedRound1.has(seat.id)
+            ? round2Prompt(question, sanitizedRound1.get(seat.id), positions, style)
+            : undefined, parent, signal, failures);
+        const sanitizedCritiques = [];
+        for (const [seat, response] of round2) {
+            const sanitized = sanitizeForRedistribution(response.value, this.maxFieldChars, identities);
+            sanitizedCritiques.push(sanitized.value);
+            redistribution[`round2.${seat}`] = sanitized.metadata;
+        }
+        await this.observer.redistribution?.(redistribution);
+        await this.transition('round2', 'round3');
+        const round3 = await this.invokeRound('round3', 'Round3', Round3Schema, seat => sanitizedRound1.has(seat.id)
+            ? round3Prompt(question, sanitizedRound1.get(seat.id), positions, sanitizedCritiques)
+            : undefined, parent, signal, failures);
+        await this.transition('round3', 'aggregated');
+        const verdict = aggregateCouncil(responseMap(round3), responseMap(round1), mapping, failures);
+        await this.transition('aggregated', 'completed');
+        return { question, style, mapping, round1, round2, round3, failures, verdict };
+    }
+}
+//# sourceMappingURL=state-machine.js.map

package/lib/seats/codex-seat.d.ts

@@ -0,0 +1,17 @@
+import type { Context } from '@deepseek-ai/cordis';
+import type { Agent } from '@deepseek-ai/dsh-agent';
+import type { SeatConnectionConfig } from '../config.js';
+import type { CouncilSeat, CouncilSeatRequest, CouncilSeatResponse, SeatHealth } from './types.js';
+/** GPT seat backed by DSH's first-party Codex subagent provider. */
+export declare class CodexSeat implements CouncilSeat {
+    private readonly ctx;
+    private readonly config;
+    readonly id: "gpt";
+    readonly provider: string;
+    readonly model: undefined;
+    constructor(ctx: Context, config: SeatConnectionConfig);
+    private execute;
+    invoke<T>(request: CouncilSeatRequest<T>, parent: Agent, signal: AbortSignal): Promise<CouncilSeatResponse<T>>;
+    healthCheck(parent: Agent, signal: AbortSignal): Promise<SeatHealth>;
+}
+//# sourceMappingURL=codex-seat.d.ts.map

package/lib/seats/codex-seat.js

@@ -0,0 +1,81 @@
+import { invokeStructured } from './structured.js';
+function visibleText(blocks) {
+    return blocks
+        .filter((block) => block.type === 'text')
+        .map(block => block.text)
+        .join('')
+        .trim();
+}
+/** GPT seat backed by DSH's first-party Codex subagent provider. */
+export class CodexSeat {
+    ctx;
+    config;
+    id = 'gpt';
+    provider;
+    model = undefined;
+    constructor(ctx, config) {
+        this.ctx = ctx;
+        this.config = config;
+        this.provider = config.provider;
+    }
+    async execute(prompt, parent, signal) {
+        const run = await this.ctx.subagents.start(this.provider, {
+            label: 'Council GPT seat',
+            prompt: [{ type: 'text', text: prompt }],
+            parent,
+            signal,
+        });
+        try {
+            const result = await run.result;
+            const text = visibleText(result.output);
+            if (result.stopReason !== 'completed') {
+                const error = new Error(result.diagnostic ?? `Codex stopped with ${result.stopReason}`);
+                error.code = result.stopReason === 'aborted' ? 'ABORTED' : 'CODEX_ERROR';
+                throw error;
+            }
+            if (text.length === 0)
+                throw new Error('Codex produced no visible final answer');
+            return { text };
+        }
+        finally {
+            await run.dispose();
+        }
+    }
+    invoke(request, parent, signal) {
+        return invokeStructured({
+            seat: this.id,
+            provider: this.provider,
+            model: undefined,
+            timeoutMs: this.config.timeoutMs,
+            maxRetries: this.config.maxRetries,
+        }, request, (prompt, callSignal) => this.execute(prompt, parent, callSignal), signal);
+    }
+    async healthCheck(parent, signal) {
+        const startedAt = Date.now();
+        const health = (ok, detail) => ({
+            ok,
+            detail,
+            provider: this.provider,
+            model: 'native Codex app-server',
+            durationMs: Math.max(0, Date.now() - startedAt),
+        });
+        if (this.ctx.subagents.getProvider(this.provider) === undefined) {
+            return health(false, `subagent provider "${this.provider}" is not registered`);
+        }
+        try {
+            const healthSignal = AbortSignal.any([signal, AbortSignal.timeout(this.config.timeoutMs)]);
+            const result = await this.execute([
+                'This is an analytical read-only health check.',
+                'Do not call tools or modify anything.',
+                'Return exactly: CODEX_SUBSCRIPTION_OK',
+            ].join('\n'), parent, healthSignal);
+            return result.text.trim() === 'CODEX_SUBSCRIPTION_OK'
+                ? health(true, 'native Codex authentication completed a real app-server child')
+                : health(false, 'Codex returned an unexpected health-check response');
+        }
+        catch (error) {
+            return health(false, error instanceof Error ? error.message : String(error));
+        }
+    }
+}
+//# sourceMappingURL=codex-seat.js.map

package/lib/seats/llm-seat.d.ts

@@ -0,0 +1,17 @@
+import type { Context } from '@deepseek-ai/cordis';
+import type { Agent } from '@deepseek-ai/dsh-agent';
+import type { LlmSeatConnectionConfig } from '../config.js';
+import type { CouncilSeat, CouncilSeatId, CouncilSeatRequest, CouncilSeatResponse, SeatHealth } from './types.js';
+/** GLM or DeepSeek seat backed by a configured DSH LLM route. */
+export declare class LlmSeat implements CouncilSeat {
+    readonly id: Extract<CouncilSeatId, 'glm' | 'deepseek'>;
+    private readonly ctx;
+    private readonly config;
+    readonly provider: string;
+    readonly model: string | undefined;
+    constructor(id: Extract<CouncilSeatId, 'glm' | 'deepseek'>, ctx: Context, config: LlmSeatConnectionConfig);
+    private execute;
+    invoke<T>(request: CouncilSeatRequest<T>, _parent: Agent, signal: AbortSignal): Promise<CouncilSeatResponse<T>>;
+    healthCheck(_parent: Agent, signal: AbortSignal): Promise<SeatHealth>;
+}
+//# sourceMappingURL=llm-seat.d.ts.map

package/lib/seats/llm-seat.js

@@ -0,0 +1,96 @@
+import { BlockAssembler, createUserMessage, } from '@deepseek-ai/dsh-llm';
+import { invokeStructured } from './structured.js';
+function finishError(finish) {
+    if (finish.kind === 'stop')
+        return undefined;
+    if (finish.kind === 'error' || finish.kind === 'aborted') {
+        const error = new Error(finish.failure.message);
+        error.code = finish.failure.code;
+        return error;
+    }
+    const error = new Error(`model stopped with ${finish.kind}`);
+    error.code = finish.kind === 'max-tokens' ? 'MAX_TOKENS' : 'UNEXPECTED_FINISH';
+    return error;
+}
+/** GLM or DeepSeek seat backed by a configured DSH LLM route. */
+export class LlmSeat {
+    id;
+    ctx;
+    config;
+    provider;
+    model;
+    constructor(id, ctx, config) {
+        this.id = id;
+        this.ctx = ctx;
+        this.config = config;
+        this.provider = config.provider;
+        this.model = config.model ?? undefined;
+    }
+    async execute(prompt, signal) {
+        if (this.model === undefined)
+            throw new Error(`${this.id} model is not configured`);
+        const message = createUserMessage({
+            source: { kind: 'plugin', plugin: 'dsh-model-jury' },
+            content: [{ type: 'text', text: prompt }],
+        });
+        const assembler = new BlockAssembler();
+        for await (const chunk of this.ctx.llm.stream({
+            provider: this.provider,
+            model: this.model,
+            messages: [message],
+            maxTokens: this.config.maxTokens,
+            signal,
+        })) {
+            signal.throwIfAborted();
+            assembler.push(chunk);
+        }
+        const terminalError = finishError(assembler.finish);
+        if (terminalError !== undefined)
+            throw terminalError;
+        const text = assembler.blocks()
+            .filter((block) => block.type === 'text')
+            .map(block => block.text)
+            .join('')
+            .trim();
+        if (text.length === 0)
+            throw new Error(`${this.id} produced no visible text`);
+        return { text, ...assembler.usage === undefined ? {} : { usage: assembler.usage } };
+    }
+    invoke(request, _parent, signal) {
+        return invokeStructured({
+            seat: this.id,
+            provider: this.provider,
+            model: this.model,
+            timeoutMs: this.config.timeoutMs,
+            maxRetries: this.config.maxRetries,
+        }, request, (prompt, callSignal) => this.execute(prompt, callSignal), signal);
+    }
+    async healthCheck(_parent, signal) {
+        const startedAt = Date.now();
+        const health = (ok, detail) => ({
+            ok,
+            detail,
+            provider: this.provider,
+            ...(this.model === undefined ? {} : { model: this.model }),
+            durationMs: Math.max(0, Date.now() - startedAt),
+        });
+        if (this.model === undefined)
+            return health(false, 'model is not configured');
+        if (!this.ctx.llm.listProviders().some(provider => provider.id === this.provider)) {
+            return health(false, `LLM provider route "${this.provider}" is not registered`);
+        }
+        try {
+            const healthSignal = AbortSignal.any([signal, AbortSignal.timeout(this.config.timeoutMs)]);
+            await this.ctx.llm.resolveModelInfo(this.provider, this.model, healthSignal);
+            const result = await this.execute('Return exactly this JSON object and nothing else: {"ok":true}', healthSignal);
+            const parsed = JSON.parse(result.text);
+            return typeof parsed === 'object' && parsed !== null && parsed.ok === true
+                ? health(true, `${this.provider}/${this.model} completed a real request`)
+                : health(false, 'provider returned an unexpected health-check response');
+        }
+        catch (error) {
+            return health(false, error instanceof Error ? error.message : String(error));
+        }
+    }
+}
+//# sourceMappingURL=llm-seat.js.map

package/lib/seats/structured.d.ts

@@ -0,0 +1,22 @@
+import type { TokenUsage } from '@deepseek-ai/dsh-llm';
+import type { CouncilSeatId, CouncilSeatRequest, CouncilSeatResponse } from './types.js';
+/** Raw visible output from one provider call. */
+export interface RawSeatResult {
+    readonly text: string;
+    readonly usage?: TokenUsage;
+}
+/** Provider call used by the shared structured-output policy. */
+export type RawSeatExecutor = (prompt: string, signal: AbortSignal) => Promise<RawSeatResult>;
+/** Runtime policy shared by Codex and LLM seats. */
+export interface StructuredInvokePolicy {
+    readonly seat: CouncilSeatId;
+    readonly provider: string;
+    readonly model: string | undefined;
+    readonly timeoutMs: number;
+    readonly maxRetries: number;
+}
+/** Parse a JSON object from plain or fenced model output. */
+export declare function parseJsonObject(raw: string): unknown;
+/** Execute, validate, and perform at most one structured repair call. */
+export declare function invokeStructured<T>(policy: StructuredInvokePolicy, request: CouncilSeatRequest<T>, execute: RawSeatExecutor, parentSignal: AbortSignal): Promise<CouncilSeatResponse<T>>;
+//# sourceMappingURL=structured.d.ts.map

package/lib/seats/structured.js

@@ -0,0 +1,126 @@
+import { repairPrompt } from '../protocol/prompts.js';
+import { SeatInvocationError } from './types.js';
+/** Parse a JSON object from plain or fenced model output. */
+export function parseJsonObject(raw) {
+    const trimmed = raw.trim();
+    const fenced = /^```(?:json)?\s*([\s\S]*?)\s*```$/iu.exec(trimmed);
+    const candidate = fenced?.[1] ?? trimmed;
+    const parsed = JSON.parse(candidate);
+    if (typeof parsed !== 'object' || parsed === null || Array.isArray(parsed)) {
+        throw new Error('response root must be a JSON object');
+    }
+    return parsed;
+}
+function errorText(error) {
+    return error instanceof Error ? error.message : String(error);
+}
+function errorCode(error) {
+    if (typeof error !== 'object' || error === null || !('code' in error))
+        return undefined;
+    return typeof error.code === 'string' ? error.code : undefined;
+}
+function isTransient(error) {
+    const code = errorCode(error)?.toUpperCase();
+    if (code !== undefined) {
+        if (['AUTH', 'MISSING_CREDENTIAL', 'INVALID_CREDENTIAL', 'INVALID_REQUEST'].includes(code))
+            return false;
+        if (['RATE_LIMIT', 'SERVER', 'TRANSPORT', 'TIMEOUT', 'STREAM_CLOSED', 'EMPTY_RESPONSE'].includes(code))
+            return true;
+        if (/^HTTP_5\d\d$/u.test(code))
+            return true;
+    }
+    const message = errorText(error).toLowerCase();
+    return /rate.?limit|temporar|timed? ?out|connection reset|transport|service unavailable/u.test(message);
+}
+function deadline(parent, timeoutMs) {
+    const controller = new AbortController();
+    const onAbort = () => controller.abort(parent.reason);
+    if (parent.aborted)
+        onAbort();
+    else
+        parent.addEventListener('abort', onAbort, { once: true });
+    const timer = setTimeout(() => controller.abort(new Error(`seat timed out after ${timeoutMs}ms`)), timeoutMs);
+    return {
+        signal: controller.signal,
+        dispose() {
+            clearTimeout(timer);
+            parent.removeEventListener('abort', onAbort);
+        },
+    };
+}
+async function callWithRetry(execute, prompt, signal, maxRetries, onRetry) {
+    let retries = 0;
+    while (true) {
+        signal.throwIfAborted();
+        try {
+            return await execute(prompt, signal);
+        }
+        catch (error) {
+            if (signal.aborted || retries >= maxRetries || !isTransient(error))
+                throw error;
+            retries += 1;
+            onRetry();
+        }
+    }
+}
+function metadata(policy, request, startedAt, success, retryCount, repairCount, usage) {
+    const endedAt = new Date();
+    return {
+        seat: policy.seat,
+        provider: policy.provider,
+        model: policy.model,
+        round: request.round,
+        startedAt: startedAt.toISOString(),
+        endedAt: endedAt.toISOString(),
+        durationMs: Math.max(0, endedAt.getTime() - startedAt.getTime()),
+        success,
+        retryCount,
+        repairCount,
+        tokenUsage: usage,
+    };
+}
+/** Execute, validate, and perform at most one structured repair call. */
+export async function invokeStructured(policy, request, execute, parentSignal) {
+    const startedAt = new Date();
+    const callDeadline = deadline(parentSignal, policy.timeoutMs);
+    let retries = 0;
+    let repairs = 0;
+    let latestUsage;
+    try {
+        let called = await callWithRetry(execute, request.prompt, callDeadline.signal, policy.maxRetries, () => { retries += 1; });
+        latestUsage = called.usage;
+        let raw = called.text;
+        let validation = request.schema.safeParse(parseJsonObjectSafely(raw));
+        if (!validation.success) {
+            repairs = 1;
+            called = await callWithRetry(execute, repairPrompt(request.prompt, raw, validation.error.message), callDeadline.signal, policy.maxRetries, () => { retries += 1; });
+            latestUsage = called.usage ?? latestUsage;
+            raw = called.text;
+            validation = request.schema.safeParse(parseJsonObjectSafely(raw));
+        }
+        if (!validation.success) {
+            throw new Error(`${request.schemaName} response remained malformed after one repair: ${validation.error.message}`);
+        }
+        return {
+            value: validation.data,
+            raw,
+            metadata: metadata(policy, request, startedAt, true, retries, repairs, latestUsage),
+        };
+    }
+    catch (error) {
+        const callMetadata = metadata(policy, request, startedAt, false, retries, repairs, latestUsage);
+        throw new SeatInvocationError(`${policy.seat} ${request.round} failed: ${errorText(error)}`, callMetadata, { cause: error });
+    }
+    finally {
+        callDeadline.dispose();
+    }
+}
+function parseJsonObjectSafely(raw) {
+    try {
+        return parseJsonObject(raw);
+    }
+    catch (error) {
+        return { __council_parse_error__: errorText(error) };
+    }
+}
+//# sourceMappingURL=structured.js.map