@inflexa-ai/harness 0.1.1

package/dist/workflows/target-assessment/synthesis/index.js

@@ -0,0 +1,351 @@
+/**
+ * Phase-5 synthesis functions for the harness DBOS workflow.
+ *
+ * Four functions:
+ *   - `liabilityBullets`        (per-section, parallel-safe)
+ *   - `safetyFlagsTrail`        (per-section, parallel-safe)
+ *   - `translationalCommentary` (per-section, parallel-safe)
+ *   - `dossierRecommendation`   (whole-dossier, sequential after the three above)
+ *
+ * Each function is a pure async `(input, deps) => Promise<EnvelopeWithDiagnostic>`.
+ * Every call is single-shot structured-output through `structuredLlmCall`.
+ *
+ * The `runSynthesisWithProbe` helper preserves the bounded-retry-on-probe-
+ * failure semantics: attempt 1 → probe → critique-driven retry → probe.
+ * Each attempt is its own attempt-numbered DBOS step so a resumed
+ * post-402 call lands a fresh cache slot.
+ */
+import { z } from "zod";
+import { SynthesisDiagnosticRowSchema } from "@inflexa-ai/harness/contracts/target-dossier.js";
+import { executiveRecommendationBrief, liabilityBulletsBrief, targetOrganLiabilitiesBrief, translationalCommentaryBrief, } from "../../../prompts/target-assessment/briefs/index.js";
+import { toxVoiceCore, toxVoiceExemplars } from "../../../prompts/target-assessment/tox-voice/index.js";
+import { SerializedErrorSchema } from "../coverage.js";
+import { buildDiagnosticsRow } from "../steps/synthesis/diagnostics.js";
+import { probeLiabilityBullets, probeRecommendation, probeSafetyFlags, probeTranslationalCommentary } from "../synthesis-probes.js";
+import { structuredLlmCall } from "../lib/structured-llm.js";
+// ── Output schemas ────────────────────────────────────────────────────
+export const LiabilityBulletsOutputSchema = z.object({
+    bullets: z.array(z.object({
+        organ_or_axis: z.string(),
+        severity: z.enum(["high", "medium", "low"]),
+        text: z.string(),
+        evidence_pointer: z.string(),
+        rationale: z.string(),
+        category: z.enum(["fatal_post_market", "class_liability", "off_target_safety", "high_safety_organ_expression", "broad_expression", "other"]),
+    })),
+    notes: z.string(),
+});
+export const SafetyFlagsTrailOutputSchema = z.object({
+    flags: z.array(z.object({
+        organ: z.string(),
+        trail: z.string(),
+        mechanism_hypothesis: z.string().nullable(),
+    })),
+});
+export const TranslationalCommentaryOutputSchema = z.object({
+    rows: z.array(z.object({
+        topic: z.enum(["ko_phenotype", "expression_translation", "organ_system_match", "family_context"]),
+        predicate: z.string(),
+        commentary: z.string(),
+    })),
+});
+export const ExternalCitationSchema = z.object({
+    id: z.string(),
+    kind: z.enum(["fda_anda", "fda_nda", "pubmed", "clinicaltrials", "regulatory_guidance"]),
+    retrieved_via: z.string(),
+    fetched_at: z.string().datetime().optional(),
+    excerpt: z.string().max(500),
+});
+export const DossierRecommendationOutputSchema = z.object({
+    disposition: z.enum(["pursue", "conditional", "de_prioritize", "insufficient_evidence"]),
+    confidence: z.enum(["high", "medium", "low"]),
+    rationale: z.string(),
+    key_strengths: z.array(z.string()),
+    key_risks: z.array(z.string()),
+    modality_choice: z.object({
+        modality: z.string(),
+        rationale: z.string(),
+    }),
+    coverage_qualifier: z.object({
+        sections_consulted: z.array(z.string()),
+        sections_unavailable: z.array(z.string()),
+        note: z.string(),
+    }),
+    external_citations: z.array(ExternalCitationSchema).default([]),
+});
+// ── Per-step envelope schemas ─────────────────────────────────────────
+function withDiagnosticAndCoverage(dataSchema) {
+    return z.discriminatedUnion("coverage", [
+        z.object({
+            coverage: z.literal("available"),
+            data: dataSchema,
+            diagnostic: SynthesisDiagnosticRowSchema,
+        }),
+        z.object({
+            coverage: z.literal("queried_no_data"),
+            error: SerializedErrorSchema.extend({
+                kind: z.enum(["synthesis-too-shallow", "synthesis-unavailable", "voice-violation"]).optional(),
+            }).optional(),
+            diagnostic: SynthesisDiagnosticRowSchema,
+        }),
+    ]);
+}
+export const LiabilityBulletsStepOutputSchema = withDiagnosticAndCoverage(LiabilityBulletsOutputSchema);
+export const SafetyFlagsTrailStepOutputSchema = withDiagnosticAndCoverage(SafetyFlagsTrailOutputSchema);
+export const TranslationalCommentaryStepOutputSchema = withDiagnosticAndCoverage(TranslationalCommentaryOutputSchema);
+export const DossierRecommendationStepOutputSchema = withDiagnosticAndCoverage(DossierRecommendationOutputSchema);
+// ── Instruction composer ─────────────────────────────────────────────
+function composeInstructions(brief, section) {
+    const exemplarBlock = toxVoiceExemplars[section].map((ex, i) => `### Exemplar ${i + 1}\n\n${ex}`).join("\n\n");
+    return [toxVoiceCore, "---", brief, "---", "## Voice exemplars", exemplarBlock].join("\n\n");
+}
+function isBudgetExceeded(v) {
+    return typeof v === "object" && v !== null && "kind" in v && v.kind === "budget-exceeded";
+}
+/**
+ * Run a synthesis call with one bounded retry on probe failure. Returns
+ * the final output (or null on permanent failure) plus a diagnostics row.
+ * On a billing-gateway 402 at any attempt, propagates the budget-exceeded sentinel.
+ */
+async function runSynthesisWithProbe(input) {
+    let firstError = null;
+    let firstProbe = null;
+    // Attempt 1
+    try {
+        const result = await structuredLlmCall({
+            stepName: `${input.baseStepName}:0`,
+            agentId: input.stepId,
+            provider: input.chatProvider,
+            session: input.session,
+            system: input.system,
+            prompt: input.basePrompt,
+            schema: input.outputSchema,
+            model: input.modelId,
+        });
+        if (result.kind === "budget-exceeded") {
+            return { kind: "budget-exceeded", sentinel: result.sentinel };
+        }
+        const firstOutput = result.value;
+        firstProbe = input.probe(firstOutput);
+        if (firstProbe.verdict === "pass" || firstProbe.verdict === "relaxed") {
+            return {
+                kind: "ok",
+                finalOut: firstOutput,
+                diagnostic: buildDiagnosticsRow({
+                    stepId: input.stepId,
+                    modelId: input.modelId,
+                    attemptCount: 1,
+                    retryCritique: null,
+                    finalProbe: firstProbe,
+                    finalCoverage: "available",
+                }),
+                errorKind: null,
+                errorMessage: null,
+            };
+        }
+    }
+    catch (err) {
+        firstError = err instanceof Error ? err : new Error(String(err));
+    }
+    // Attempt 2 — critique-driven retry. On hard first-attempt throw, the
+    // retry uses the base prompt prefixed with the throw message.
+    const retryCritique = firstProbe?.critique ?? (firstError ? `Your prior attempt threw: ${firstError.message}. Try again.` : null);
+    const retryPrompt = retryCritique != null ? `${input.basePrompt}\n\n---\n\nIMPORTANT: ${retryCritique}` : input.basePrompt;
+    try {
+        const result = await structuredLlmCall({
+            stepName: `${input.baseStepName}:1`,
+            agentId: input.stepId,
+            provider: input.chatProvider,
+            session: input.session,
+            system: input.system,
+            prompt: retryPrompt,
+            schema: input.outputSchema,
+            model: input.modelId,
+        });
+        if (result.kind === "budget-exceeded") {
+            return { kind: "budget-exceeded", sentinel: result.sentinel };
+        }
+        const retryOutput = result.value;
+        const retryProbe = input.probe(retryOutput);
+        if (retryProbe.verdict === "pass" || retryProbe.verdict === "relaxed") {
+            return {
+                kind: "ok",
+                finalOut: retryOutput,
+                diagnostic: buildDiagnosticsRow({
+                    stepId: input.stepId,
+                    modelId: input.modelId,
+                    attemptCount: 2,
+                    retryCritique,
+                    finalProbe: retryProbe,
+                    finalCoverage: "available",
+                }),
+                errorKind: null,
+                errorMessage: null,
+            };
+        }
+        const errorKind = retryProbe.verdict === "fail-voice" ? "voice-violation" : "synthesis-too-shallow";
+        return {
+            kind: "ok",
+            finalOut: null,
+            diagnostic: buildDiagnosticsRow({
+                stepId: input.stepId,
+                modelId: input.modelId,
+                attemptCount: 2,
+                retryCritique,
+                finalProbe: retryProbe,
+                finalCoverage: "queried_no_data",
+                errorKind,
+                errorMessage: retryProbe.critique,
+            }),
+            errorKind,
+            errorMessage: retryProbe.critique,
+        };
+    }
+    catch (err) {
+        const errMsg = err instanceof Error ? err.message : String(err);
+        return {
+            kind: "ok",
+            finalOut: null,
+            diagnostic: buildDiagnosticsRow({
+                stepId: input.stepId,
+                modelId: input.modelId,
+                attemptCount: 2,
+                retryCritique,
+                finalProbe: firstProbe ?? {
+                    verdict: "skipped",
+                    critique: errMsg,
+                    output_chars: 0,
+                },
+                finalCoverage: "queried_no_data",
+                errorKind: "synthesis-unavailable",
+                errorMessage: errMsg,
+            }),
+            errorKind: "synthesis-unavailable",
+            errorMessage: errMsg,
+        };
+    }
+}
+function envelopeFromDriverResult(driver) {
+    if (driver.finalOut) {
+        return {
+            coverage: "available",
+            data: driver.finalOut,
+            diagnostic: driver.diagnostic,
+        };
+    }
+    return {
+        coverage: "queried_no_data",
+        error: {
+            message: driver.errorMessage ?? "synthesis failed",
+            name: driver.errorKind ?? "synthesis-unavailable",
+            kind: driver.errorKind ?? "synthesis-unavailable",
+        },
+        diagnostic: driver.diagnostic,
+    };
+}
+export async function liabilityBullets(phase4, deps) {
+    const prompt = [
+        "Phase-4 dossier — write evidence-cited liability bullets.",
+        "The full assembled dossier follows. Cite section paths and counts; do not fabricate.",
+        "",
+        JSON.stringify(phase4.dossier, null, 2),
+        "",
+        deps.approvalPrecedents,
+    ].join("\n");
+    const result = await runSynthesisWithProbe({
+        stepId: "liability-bullets",
+        modelId: deps.model,
+        system: composeInstructions(liabilityBulletsBrief, "liability-bullets"),
+        basePrompt: prompt,
+        outputSchema: LiabilityBulletsOutputSchema,
+        probe: (out) => probeLiabilityBullets(out, phase4.dossier),
+        chatProvider: deps.chatProvider,
+        session: deps.session,
+        baseStepName: `ta-synth:liability-bullets:${deps.attempt}`,
+    });
+    if (result.kind === "budget-exceeded")
+        return result;
+    return envelopeFromDriverResult(result);
+}
+export async function safetyFlagsTrail(phase4, deps) {
+    const prompt = [
+        "Phase-4 dossier — write per-organ safety-flag audit trails.",
+        "The full assembled dossier follows. Cite source counts; do not fabricate.",
+        "",
+        JSON.stringify(phase4.dossier, null, 2),
+        "",
+        deps.approvalPrecedents,
+    ].join("\n");
+    const result = await runSynthesisWithProbe({
+        stepId: "safety-flags-trail",
+        modelId: deps.model,
+        system: composeInstructions(targetOrganLiabilitiesBrief, "target-organ-liabilities"),
+        basePrompt: prompt,
+        outputSchema: SafetyFlagsTrailOutputSchema,
+        probe: probeSafetyFlags,
+        chatProvider: deps.chatProvider,
+        session: deps.session,
+        baseStepName: `ta-synth:safety-flags-trail:${deps.attempt}`,
+    });
+    if (result.kind === "budget-exceeded")
+        return result;
+    return envelopeFromDriverResult(result);
+}
+export async function translationalCommentary(phase4, deps) {
+    const prompt = [
+        "Phase-4 dossier — write preclinical-to-clinical translational commentary.",
+        "The full assembled dossier follows. Cite tissues and species literally; do not fabricate.",
+        "",
+        JSON.stringify(phase4.dossier, null, 2),
+        "",
+        deps.approvalPrecedents,
+    ].join("\n");
+    const result = await runSynthesisWithProbe({
+        stepId: "translational-commentary",
+        modelId: deps.model,
+        system: composeInstructions(translationalCommentaryBrief, "translational-commentary"),
+        basePrompt: prompt,
+        outputSchema: TranslationalCommentaryOutputSchema,
+        probe: probeTranslationalCommentary,
+        chatProvider: deps.chatProvider,
+        session: deps.session,
+        baseStepName: `ta-synth:translational-commentary:${deps.attempt}`,
+    });
+    if (result.kind === "budget-exceeded")
+        return result;
+    return envelopeFromDriverResult(result);
+}
+export async function dossierRecommendation(input, deps) {
+    // Surface just the data envelopes from the per-section synthesis outputs;
+    // drop the diagnostic so the recommendation agent isn't tempted to read
+    // its own machinery.
+    const perSectionPrompt = {
+        liability_bullets: input.perSection.liabilityBullets.coverage === "available" ? input.perSection.liabilityBullets.data : { coverage: "queried_no_data" },
+        target_organ_liabilities: input.perSection.safetyFlagsTrail.coverage === "available" ? input.perSection.safetyFlagsTrail.data : { coverage: "queried_no_data" },
+        translational_commentary: input.perSection.translationalCommentary.coverage === "available" ? input.perSection.translationalCommentary.data : { coverage: "queried_no_data" },
+    };
+    const prompt = [
+        "Phase-4 dossier — produce the executive recommendation.",
+        "Inputs are: (1) the full assembled dossier, (2) the three per-section synthesis outputs.",
+        "Cite at least three section paths from the dossier, integrate the per-section bullets/flags/commentary, and disclose coverage gaps explicitly.",
+        "",
+        JSON.stringify({ dossier: input.phase4.dossier, per_section_synthesis: perSectionPrompt }, null, 2),
+        "",
+        deps.approvalPrecedents,
+    ].join("\n");
+    const result = await runSynthesisWithProbe({
+        stepId: "dossier-recommendation",
+        modelId: deps.model,
+        system: composeInstructions(executiveRecommendationBrief, "executive-recommendation"),
+        basePrompt: prompt,
+        outputSchema: DossierRecommendationOutputSchema,
+        probe: (out) => probeRecommendation(out, input.phase4.dossier),
+        chatProvider: deps.chatProvider,
+        session: deps.session,
+        baseStepName: `ta-synth:dossier-recommendation:${deps.attempt}`,
+    });
+    if (result.kind === "budget-exceeded")
+        return result;
+    return envelopeFromDriverResult(result);
+}
+export { isBudgetExceeded as isSynthesisBudgetExceeded };

package/dist/workflows/target-assessment/synthesis-probes.d.ts

@@ -0,0 +1,56 @@
+/**
+ * Synthesis content probes — deterministic floor on Phase-5 LLM output
+ * depth.
+ *
+ * Each per-section synthesis step runs its agent's structured output
+ * through the relevant probe before accepting it. A failed probe
+ * triggers one bounded retry with a critique appended; a second failure
+ * marks the section `coverage: "queried_no_data"` with
+ * `error.kind: "synthesis-too-shallow"` (the workflow proceeds — the
+ * dossier still persists with the rest of the data intact).
+ *
+ * Probes are deliberately deterministic regex/length checks — not
+ * LLM-as-judge. The prompts already require evidence citation; the
+ * probes are a regression-prevention floor for the rare LLM regression
+ * that produces fragment-length output anyway.
+ *
+ * Threshold tuning: the constants block at the top of this file is the
+ * single source of truth. Adjust there, never inline.
+ */
+import type { DossierV4Body, DossierV5Body } from "@inflexa-ai/harness/contracts/target-dossier.js";
+import type { DossierRecommendationOutput, LiabilityBulletsOutput, SafetyFlagsTrailOutput, TranslationalCommentaryOutput } from "./synthesis/index.js";
+export declare const PROBE_THRESHOLDS: {
+    readonly recommendation: {
+        readonly rationaleMinChars: 600;
+        readonly rationaleMinCharsRelaxed: 200;
+        readonly requiredSectionRefs: 3;
+        readonly requiredKeyItems: 1;
+    };
+    readonly liabilityBullet: {
+        readonly rationaleMinChars: 80;
+        readonly requiresSourceOrCounter: true;
+    };
+    readonly safetyFlag: {
+        readonly trailMinChars: 100;
+        readonly requiredSourceRefs: 2;
+    };
+    readonly translationalCommentary: {
+        readonly commentaryMinChars: 120;
+    };
+};
+export type ProbeVerdict = "pass" | "fail-length" | "fail-section-references" | "fail-key-strengths-risks" | "fail-source-references" | "fail-numeric-claim" | "fail-voice" | "relaxed" | "skipped";
+export interface ProbeResult {
+    verdict: ProbeVerdict;
+    critique: string | null;
+    output_chars: number;
+}
+export declare function countSectionReferences(text: string): {
+    matchedSections: string[];
+};
+export declare function countSourceReferences(text: string): {
+    matchedSources: string[];
+};
+export declare function probeRecommendation(out: DossierRecommendationOutput, dossier: DossierV4Body | DossierV5Body): ProbeResult;
+export declare function probeLiabilityBullets(out: LiabilityBulletsOutput, dossier?: DossierV4Body | DossierV5Body): ProbeResult;
+export declare function probeSafetyFlags(out: SafetyFlagsTrailOutput): ProbeResult;
+export declare function probeTranslationalCommentary(out: TranslationalCommentaryOutput): ProbeResult;