@inflexa-ai/harness 0.1.1

package/dist/workflows/target-assessment/lib/llm-step.js

@@ -0,0 +1,99 @@
+/**
+ * LLM step wrapper for the target-assessment DBOS workflow body.
+ *
+ * Each Phase-2 decision and Phase-5 synthesis LLM call goes through
+ * `runLlmStep` — it wraps `DBOS.runStep({name})` around the chat provider
+ * call and classifies caught errors:
+ *
+ *   - `isBudgetExceeded(err) === true` (billing-gateway 402): self-send a
+ *     `BUDGET_EXCEEDED_TOPIC` marker addressed to this workflow's own
+ *     id, then return a sentinel marker. The wrapper does NOT call
+ *     `DBOS.cancelWorkflow` itself — the workflow body's terminal block
+ *     reads the marker, writes `status = "suspended_insufficient_funds"`
+ *     via `DBOS.runStep({name: "ta-terminal-suspended"})`, then issues
+ *     `DBOS.cancelWorkflow` + a trailing `runStep` to materialise the
+ *     CANCELLED terminal state. Deferring the cancel keeps the terminal
+ *     handler's DB writes inside DBOS step boundaries (replay-cached).
+ *   - anything else: rethrow so the caller wraps the failure as
+ *     `coverage: "queried_no_data"` with `error.kind: "synthesis-unavailable"`
+ *     (or `"queried_no_data"` for decisions).
+ *
+ * The step name is attempt-numbered by the caller — e.g.
+ * `"ta-synth:liability-bullets:0"`. On 402 + top-up + `DBOS.resumeWorkflow`
+ * the caller bumps the attempt counter so the resumed call lands a fresh
+ * DBOS cache slot rather than replaying the cancelled prior attempt.
+ */
+import { DBOS } from "@dbos-inc/dbos-sdk";
+import { unwrapOrThrow } from "../../../lib/result.js";
+import { isBudgetExceeded } from "../../../loop/budget-exceeded.js";
+/**
+ * DBOS message topic the LLM step uses to mark the workflow as
+ * self-cancelled on a billing-gateway 402. The terminal handler drains the topic
+ * to dispatch to `markAssessmentSuspended` rather than the generic
+ * operator-cancel handler.
+ */
+export const BUDGET_EXCEEDED_TOPIC = "ta-budget-exceeded";
+/**
+ * Sentinel returned (NOT thrown) when the wrapper has self-cancelled the
+ * workflow. The next `DBOS.runStep` after this point raises
+ * `DBOSWorkflowCancelledError`, so call sites only see this value on the
+ * synchronous return path before the cancel materialises. Callers MUST NOT
+ * wrap this as `coverage: "queried_no_data"` — the workflow is unwinding.
+ */
+export const BUDGET_EXCEEDED_SENTINEL = Symbol.for("ta.budget-exceeded");
+/**
+ * Run one LLM call inside a `DBOS.runStep` boundary. On a billing-gateway 402 the
+ * workflow self-cancels and the caller receives a sentinel result; on any
+ * other throw the original error rethrows.
+ */
+export async function runLlmStep(opts) {
+    const { stepName, agentId, provider, req, session, signal } = opts;
+    try {
+        const response = await DBOS.runStep(async () => unwrapOrThrow(await provider.chat(req, session, signal)), { name: stepName });
+        return { kind: "ok", response };
+    }
+    catch (err) {
+        if (!isBudgetExceeded(err)) {
+            throw err;
+        }
+        const workflowId = DBOS.workflowID;
+        if (!workflowId) {
+            // Should not happen — the wrapper is only callable from inside a
+            // workflow body. Surface as a generic throw so the caller does not
+            // misclassify as coverage failure.
+            throw err;
+        }
+        const marker = {
+            stepName,
+            agentId,
+            error: err instanceof Error ? err.message : String(err),
+        };
+        // Self-send a marker so the terminal handler's `DBOS.recv(topic, 0)`
+        // drain sees it before the body unwinds. DBOS persists the send under
+        // (workflowID, function_id), so replay does not duplicate the
+        // marker. The send is wrapped in `DBOS.runStep` to own the slot.
+        //
+        // The workflow is NOT cancelled here — the body propagates the
+        // sentinel through phase outputs, the terminal block runs its DB
+        // writes inside DBOS step boundaries, and the cancel materialises at
+        // the very end via the terminal block's trailing
+        // `DBOS.cancelWorkflow` + `DBOS.runStep("self-cancel-budget-exceeded")`.
+        try {
+            await DBOS.runStep(() => DBOS.send(workflowId, marker, BUDGET_EXCEEDED_TOPIC), { name: `${stepName}:notify-budget-exceeded` });
+        }
+        catch (sendErr) {
+            console.warn(`[ta-llm-step] notify-budget-exceeded send failed (non-fatal): ${sendErr instanceof Error ? sendErr.message : sendErr}`);
+        }
+        return { kind: "budget-exceeded", sentinel: BUDGET_EXCEEDED_SENTINEL };
+    }
+}
+/**
+ * Drain the budget-exceeded topic for this workflow. Called from the
+ * terminal handler (after the body has unwound) to decide whether the
+ * workflow cancelled because of a 402 or because of an operator-initiated
+ * cancel. Returns the first marker (or `null` if none queued).
+ */
+export async function readBudgetExceededMarker() {
+    const msg = await DBOS.recv(BUDGET_EXCEEDED_TOPIC, 0);
+    return msg ?? null;
+}

package/dist/workflows/target-assessment/lib/meddra-organ-map.d.ts

@@ -0,0 +1,30 @@
+export type CanonicalOrgan = "cardiac" | "hepatic" | "cns" | "renal" | "gi" | "pancreas" | "endocrine_thyroid" | "metabolic" | "hematologic" | "immune" | "respiratory" | "reproductive" | "dermatologic" | "musculoskeletal" | "oncology";
+export declare function classifyOrgan(meddraTerm: string): CanonicalOrgan | null;
+/**
+ * MedDRA SOC (System Organ Class) names as they appear in CT.gov structured
+ * AE tables → canonical organ. SOC strings (e.g. "Gastrointestinal disorders")
+ * do not contain MedDRA PT stems, so `classifyOrgan` returns null for them —
+ * the SOC map is the primary path; `classifyOrgan(term)` is the fallback when
+ * the SOC string isn't in the map.
+ */
+export declare const TRIAL_AE_ORGAN_MAP: Record<string, CanonicalOrgan>;
+/**
+ * Classify a trial AE row by its SOC (preferred) or its individual MedDRA
+ * preferred term (fallback). Shared between the Phase-4 assembler's
+ * organ_rollup builder and the derived-completeness validator so both
+ * agree on which organ a trial AE belongs to.
+ */
+export declare function classifyTrialAe(ae: {
+    term?: string | null;
+    organ?: string | null;
+}): CanonicalOrgan | null;
+/**
+ * Classify a polypharm off-target panel row by its canonical `organ_system`
+ * string (set by the curated safety panel — `cardiac` | `hepatic` | `cns` |
+ * `renal` | `gi` | `hematologic` | `immune` | `metabolic` | `respiratory`).
+ *
+ * Falls back to `classifyOrgan` if the upstream string is non-canonical;
+ * this preserves coverage if a future collector emits MedDRA terms instead
+ * of canonical organ names.
+ */
+export declare function classifyPolypharmOrgan(organSystem: string | null | undefined): CanonicalOrgan | null;

package/dist/workflows/target-assessment/lib/meddra-organ-map.js

@@ -0,0 +1,126 @@
+/**
+ * Order matters: more-specific patterns first. GI is matched before
+ * "metabolic" because terms like "blood glucose" should land in
+ * metabolic, but "nausea" / "vomiting" must not be reclassified by
+ * later metabolic glucose rules.
+ *
+ * Patterns are stem-based (e.g. "nause" matches "NAUSEA"), so trailing
+ * \b is omitted — the stem does not end at a word boundary inside the
+ * full MedDRA term. A leading \b is kept to prevent mid-word false matches.
+ */
+const RULES = [
+    // pancreas (specific) — must come before generic GI
+    { rx: /\bpancreatit|\bamylase|\blipase/i, organ: "pancreas" },
+    // thyroid / C-cell
+    { rx: /\b(thyroid|c[-\s]?cell|calcitonin|goit[re]+|medullar[a-z]*\s*(?:thyroid|carcinoma))/i, organ: "endocrine_thyroid" },
+    // gastrointestinal
+    { rx: /\b(nause|vomit|diarrhoe|diarrhea|constipat|ileus|gastropares|abdominal\s*pain|cholecystit|cholelithias|gallbladder|colit|heartburn)/i, organ: "gi" },
+    // hepatic — liver/alt/ast forms added; alt/ast pinned to "increased" to avoid
+    // over-firing on terms like "ALTERED MENTAL STATUS"
+    {
+        rx: /\b(hepatit|hepato|jaundic|cholestas|transaminas|bilirubin|liver|alt\s+increased|ast\s+increased|alanine\s+aminotransferase|aspartate\s+aminotransferase)/i,
+        organ: "hepatic",
+    },
+    // renal — haematur/hematur explicitly placed here (above hematologic) to prevent
+    // the broad \bhaemat stem from misclassifying HAEMATURIA as hematologic
+    { rx: /\b(renal|kidney|nephro|creatinin|glomerul|dialys|haematur|hematur)/i, organ: "renal" },
+    // cardiac — cardi(ac|al|o) covers CARDIOMYOPATHY/CARDIOVASCULAR/CARDIOTOXICITY;
+    // bare heart covers HEART FAILURE, HEART RATE INCREASED, etc.
+    { rx: /\b(cardi(?:ac|al|o)|heart|myocard|tachycard|brady\w*card|arrhythm|atrial\s+fibrillat|qt\s+prolong|torsade)/i, organ: "cardiac" },
+    // metabolic (glucose, weight, lipid)
+    // triglyc has no leading \b because it appears mid-word in HYPERTRIGLYCERIDAEMIA
+    { rx: /\b(glucose|glycaemi|hba1c|insulin|weight\s+(?:decreased|increased)|lipid|cholester|dehydration)|triglyc/i, organ: "metabolic" },
+    // cns
+    { rx: /\b(headache|dizz|seizure|suici|depression|anxiet|paraesthes|neuropath|encephalo|migrain)/i, organ: "cns" },
+    // hematologic
+    { rx: /\b(haemoglobin|hemoglobin|haematocrit|leuko|neutro|thrombocyt|anaemi|haemat|platelet)/i, organ: "hematologic" },
+    // respiratory
+    { rx: /\b(nasopharyng|pharyng|bronch|pneumon|dyspnoe|dyspnea|cough|respiratory|sinusit)/i, organ: "respiratory" },
+    // dermatologic
+    { rx: /\b(rash|eczem|prurit|urticari|injection\s+site\s+(?:pain|haemorrhag|erythem))/i, organ: "dermatologic" },
+    // musculoskeletal
+    { rx: /\b(arthralg|myalg|musculoskel|fracture|bone\s+pain)/i, organ: "musculoskeletal" },
+    // immune
+    { rx: /\b(hypersensitiv|anaphyl|autoimmune|cytokine\s+release)/i, organ: "immune" },
+    // reproductive
+    { rx: /\b(menstrual|menorrhag|ovari|endometr|prostat|erectile)/i, organ: "reproductive" },
+];
+const UNINFORMATIVE_RE = /\b(incorrect\s+dose|off\s+label|drug\s+ineffective|product\s+(?:use|storage|administration)|accidental\s+exposure|inappropriate\s+schedule|exposure\s+via\s+skin|extra\s+dose|wrong\s+technique)\b/i;
+export function classifyOrgan(meddraTerm) {
+    if (UNINFORMATIVE_RE.test(meddraTerm))
+        return null;
+    for (const { rx, organ } of RULES) {
+        if (rx.test(meddraTerm))
+            return organ;
+    }
+    return null;
+}
+/**
+ * MedDRA SOC (System Organ Class) names as they appear in CT.gov structured
+ * AE tables → canonical organ. SOC strings (e.g. "Gastrointestinal disorders")
+ * do not contain MedDRA PT stems, so `classifyOrgan` returns null for them —
+ * the SOC map is the primary path; `classifyOrgan(term)` is the fallback when
+ * the SOC string isn't in the map.
+ */
+export const TRIAL_AE_ORGAN_MAP = {
+    "Gastrointestinal disorders": "gi",
+    "Cardiac disorders": "cardiac",
+    "Nervous system disorders": "cns",
+    "Hepatobiliary disorders": "hepatic",
+    "Renal and urinary disorders": "renal",
+    "Endocrine disorders": "endocrine_thyroid",
+    "Respiratory, thoracic and mediastinal disorders": "respiratory",
+    "Skin and subcutaneous tissue disorders": "dermatologic",
+    "Musculoskeletal and connective tissue disorders": "musculoskeletal",
+    "Metabolism and nutrition disorders": "metabolic",
+    "Blood and lymphatic system disorders": "hematologic",
+    "Reproductive system and breast disorders": "reproductive",
+    "Immune system disorders": "immune",
+};
+/**
+ * Classify a trial AE row by its SOC (preferred) or its individual MedDRA
+ * preferred term (fallback). Shared between the Phase-4 assembler's
+ * organ_rollup builder and the derived-completeness validator so both
+ * agree on which organ a trial AE belongs to.
+ */
+export function classifyTrialAe(ae) {
+    const fromSoc = TRIAL_AE_ORGAN_MAP[ae.organ ?? ""];
+    if (fromSoc)
+        return fromSoc;
+    return classifyOrgan(ae.term ?? "");
+}
+/**
+ * Classify a polypharm off-target panel row by its canonical `organ_system`
+ * string (set by the curated safety panel — `cardiac` | `hepatic` | `cns` |
+ * `renal` | `gi` | `hematologic` | `immune` | `metabolic` | `respiratory`).
+ *
+ * Falls back to `classifyOrgan` if the upstream string is non-canonical;
+ * this preserves coverage if a future collector emits MedDRA terms instead
+ * of canonical organ names.
+ */
+export function classifyPolypharmOrgan(organSystem) {
+    const sys = (organSystem ?? "").toLowerCase().trim();
+    if (!sys)
+        return null;
+    // Canonical names from the safety panel enum match by direct string equality.
+    if (CANONICAL_ORGAN_NAMES.has(sys))
+        return sys;
+    return classifyOrgan(sys);
+}
+const CANONICAL_ORGAN_NAMES = new Set([
+    "cardiac",
+    "hepatic",
+    "cns",
+    "renal",
+    "gi",
+    "pancreas",
+    "endocrine_thyroid",
+    "metabolic",
+    "hematologic",
+    "immune",
+    "respiratory",
+    "reproductive",
+    "dermatologic",
+    "musculoskeletal",
+    "oncology",
+]);

package/dist/workflows/target-assessment/lib/recommendation-quality-gates.d.ts

@@ -0,0 +1,17 @@
+import type { ExecutiveRecommendation, QualityGateStatus, RecommendationAudit, SynthesisDiagnosticRow } from "@inflexa-ai/harness/contracts/target-dossier.js";
+type ApplyRecommendationQualityGatesInput = {
+    executive_recommendation: ExecutiveRecommendation;
+    synthesis_diagnostics: Array<Partial<SynthesisDiagnosticRow> & {
+        step_id?: string;
+    }>;
+    recommendation_audit: Extract<RecommendationAudit, {
+        coverage: "available";
+    }>["data"] | null | undefined;
+    has_direct_clinical_evidence: boolean;
+};
+type ApplyRecommendationQualityGatesResult = {
+    executive_recommendation: ExecutiveRecommendation;
+    quality_gates: QualityGateStatus[];
+};
+export declare function applyRecommendationQualityGates(input: ApplyRecommendationQualityGatesInput): ApplyRecommendationQualityGatesResult;
+export {};

package/dist/workflows/target-assessment/lib/recommendation-quality-gates.js

@@ -0,0 +1,99 @@
+const ORGAN_CLAIM_RE = /\b(renal|kidney|nephro\w*|cns|brain|hypothalam\w*|cardiac|cardiovascular|hepatic|liver|pulmonary|respiratory|gastrointestinal|gi|oncology|malignan\w*)\b/i;
+function appendNote(current, addition) {
+    const trimmed = current.trim();
+    return trimmed ? `${trimmed} ${addition}` : addition;
+}
+export function applyRecommendationQualityGates(input) {
+    const quality_gates = [];
+    const executive_recommendation = structuredClone(input.executive_recommendation);
+    const unresolved = input.recommendation_audit?.citations_unresolved ?? [];
+    const visibleRecommendationText = input.executive_recommendation.coverage === "available"
+        ? [
+            input.executive_recommendation.data.rationale,
+            input.executive_recommendation.data.modality_choice.rationale,
+            ...input.executive_recommendation.data.key_strengths,
+            ...input.executive_recommendation.data.key_risks,
+        ].join("\n")
+        : "";
+    const blockingCitationCount = unresolved.filter((u) => {
+        // The unresolved-citation entries are an untyped audit payload narrowed
+        // here to the fields these gates read; `excerpt` exists only on some
+        // surfaces, guarded by the `in` presence check.
+        if (u.surface === "organ_claim_without_probe_pass" && "excerpt" in u) {
+            const excerpt = String(u.excerpt ?? "");
+            return excerpt.length > 0 && visibleRecommendationText.includes(excerpt.slice(0, Math.min(80, excerpt.length)));
+        }
+        return ["external_missing", "nct_wrong_class", "organ_claim_without_probe_pass", "off_topic_citation"].includes(u.surface);
+    }).length;
+    if (blockingCitationCount > 0) {
+        quality_gates.push({
+            gate_id: "recommendation-citations",
+            status: "blocked",
+            message: "Recommendation contains unresolved or unsafe citation references.",
+            affected_sections: ["executive_recommendation"],
+            unresolved_count: blockingCitationCount,
+        });
+        return {
+            executive_recommendation: {
+                coverage: "queried_no_data",
+                error: {
+                    message: "executive recommendation blocked because unresolved citation audit findings remain",
+                    source: "recommendation-quality-gates",
+                },
+            },
+            quality_gates,
+        };
+    }
+    const safetyFlags = input.synthesis_diagnostics.find((row) => row.step_id === "safety-flags-trail");
+    const safetyFlagsAvailable = safetyFlags?.final_coverage === "available";
+    if (!safetyFlagsAvailable && executive_recommendation.coverage === "available") {
+        const rec = executive_recommendation.data;
+        const unverified = rec.key_risks
+            .filter((risk) => ORGAN_CLAIM_RE.test(risk))
+            .map((risk) => ({
+            text: risk,
+            bullet_category: "organ_claim_without_probe_pass",
+            surface: "organ_claim_without_probe_pass",
+        }));
+        if (unverified.length > 0) {
+            rec.key_risks = rec.key_risks.filter((risk) => !ORGAN_CLAIM_RE.test(risk));
+            rec.coverage_qualifier = {
+                ...rec.coverage_qualifier,
+                unverified_bullets: [...(rec.coverage_qualifier.unverified_bullets ?? []), ...unverified],
+                note: appendNote(rec.coverage_qualifier.note, "Organ-level risk bullets were demoted because the safety-flags audit trail did not pass validation."),
+            };
+            quality_gates.push({
+                gate_id: "safety-flags-trail",
+                status: "blocked",
+                message: "Organ-level executive risk claims were demoted because safety-flags-trail was unavailable or failed validation.",
+                affected_sections: ["executive_recommendation.key_risks"],
+                unresolved_count: unverified.length,
+            });
+        }
+    }
+    if (!input.has_direct_clinical_evidence && executive_recommendation.coverage === "available") {
+        const rec = executive_recommendation.data;
+        if (rec.confidence !== "low") {
+            rec.confidence = "low";
+        }
+        rec.coverage_qualifier = {
+            ...rec.coverage_qualifier,
+            note: appendNote(rec.coverage_qualifier.note, "No direct target-modulator clinical evidence was available; recommendation confidence is capped at low."),
+        };
+        quality_gates.push({
+            gate_id: "direct-clinical-evidence",
+            status: "warning",
+            message: "No direct target-modulator clinical evidence is available, so confidence is capped at low.",
+            affected_sections: ["executive_recommendation"],
+        });
+    }
+    if (!quality_gates.some((g) => g.status === "blocked")) {
+        quality_gates.push({
+            gate_id: "recommendation-quality",
+            status: "pass",
+            message: "No blocking recommendation quality issues detected.",
+            affected_sections: ["executive_recommendation"],
+        });
+    }
+    return { executive_recommendation, quality_gates };
+}

package/dist/workflows/target-assessment/lib/recommendation-sanitizer.d.ts

@@ -0,0 +1,2 @@
+import type { DossierRecommendationOutput } from "../synthesis/index.js";
+export declare function sanitizeRecommendation(rec: DossierRecommendationOutput): DossierRecommendationOutput;

package/dist/workflows/target-assessment/lib/recommendation-sanitizer.js

@@ -0,0 +1,51 @@
+/**
+ * Strip pipeline scaffold tokens from user-visible recommendation prose.
+ *
+ * The Phase-5 dossier-recommendation agent occasionally echoes internal
+ * indexing paths it saw in its delegation prompt — strings like
+ * `per_section_synthesis.liability_bullets[0]` and parenthetical lists
+ * containing them. These are scaffolding for the build pipeline; a
+ * toxicologist reading the final dossier should never see them.
+ *
+ * The sanitizer removes the tokens and their parenthetical wrappers,
+ * collapses the resulting double whitespace, and preserves surrounding
+ * sentence punctuation.
+ */
+const SCAFFOLD_TOKEN_RE = /per_section_synthesis\.[A-Za-z_][\w.]*(?:\[[\d–-]+\])?(?:\s+row\s+\d+)?/g;
+// Citations to dossier.per_section_synthesis.* — this namespace doesn't exist
+// in the v4 schema. The synthesis prompt occasionally emits these paths;
+// strip them to prevent non-resolvable citations in recommendation prose.
+const INVALID_PATH_RE = /\(?dossier\.per_section_synthesis\.[a-z_.[\]0-9]*\)?/gi;
+// Dangling "dossier." with no path suffix is leftover templating; strip it.
+const DANGLING_DOSSIER_RE = /\bdossier\.(?=\s|$|[.,;])/g;
+function stripScaffold(text) {
+    if (!text)
+        return text;
+    let out = text;
+    // First pass: remove a parenthetical that contains a scaffold token,
+    // along with its trailing punctuation if it directly precedes one.
+    out = out.replace(/\s*\([^()]*per_section_synthesis\.[^()]*\)/g, "");
+    // Second pass: any leftover scaffold tokens not inside parens.
+    out = out.replace(SCAFFOLD_TOKEN_RE, "");
+    // Strip dossier.per_section_synthesis.* invalid paths and dangling dossier. placeholders.
+    out = out.replace(INVALID_PATH_RE, "").replace(DANGLING_DOSSIER_RE, "");
+    // Collapse double whitespace.
+    out = out.replace(/\s{2,}/g, " ").replace(/\s+([,.;:])/g, "$1");
+    return out.trim();
+}
+export function sanitizeRecommendation(rec) {
+    return {
+        ...rec,
+        rationale: stripScaffold(rec.rationale),
+        key_strengths: rec.key_strengths.map(stripScaffold),
+        key_risks: rec.key_risks.map(stripScaffold),
+        modality_choice: {
+            ...rec.modality_choice,
+            rationale: stripScaffold(rec.modality_choice.rationale),
+        },
+        coverage_qualifier: {
+            ...rec.coverage_qualifier,
+            note: stripScaffold(rec.coverage_qualifier.note),
+        },
+    };
+}

package/dist/workflows/target-assessment/lib/regulatory-actions.d.ts

@@ -0,0 +1,26 @@
+/**
+ * Per-drug regulatory-action collector. Queries openFDA Structured Product
+ * Labels (boxed warning, Section 5 warnings_and_cautions, REMS indicator)
+ * and the EMA referrals catalogue (Article 31 / Article 20 procedures)
+ * for each drug, then maps both into the dossier's RegulatoryActionRow
+ * shape.
+ *
+ * This is the data-source replacement for the hand-curated calcitonin seed
+ * that previously lived next to it. Coverage that legitimately has no
+ * machine-readable source (e.g., EMA assessment-report procedure codes like
+ * EMEA/H/A-31/1291) is omitted rather than backfilled with curation — the
+ * source_url points at the canonical document where the human reader can
+ * extract the additional context.
+ */
+import type { RegulatoryActionRowV5 as RegulatoryActionRow } from "@inflexa-ai/harness/contracts/target-dossier.js";
+export interface DrugForRegulatoryActions {
+    chemblId: string;
+    name: string;
+}
+/**
+ * Fetch regulatory actions (FDA label + EMA referrals) for a set of drugs.
+ * Per-drug failures are isolated — one drug throwing does not blank out
+ * the rest. Returns an empty array when no drugs are provided or no source
+ * returned any actions.
+ */
+export declare function fetchRegulatoryActions(drugs: DrugForRegulatoryActions[]): Promise<RegulatoryActionRow[]>;

package/dist/workflows/target-assessment/lib/regulatory-actions.js

@@ -0,0 +1,147 @@
+/**
+ * Per-drug regulatory-action collector. Queries openFDA Structured Product
+ * Labels (boxed warning, Section 5 warnings_and_cautions, REMS indicator)
+ * and the EMA referrals catalogue (Article 31 / Article 20 procedures)
+ * for each drug, then maps both into the dossier's RegulatoryActionRow
+ * shape.
+ *
+ * This is the data-source replacement for the hand-curated calcitonin seed
+ * that previously lived next to it. Coverage that legitimately has no
+ * machine-readable source (e.g., EMA assessment-report procedure codes like
+ * EMEA/H/A-31/1291) is omitted rather than backfilled with curation — the
+ * source_url points at the canonical document where the human reader can
+ * extract the additional context.
+ */
+import { withHost } from "../../../lib/host-concurrency.js";
+import { getReferralsByDrug } from "../../../tools/lib/ema-client.js";
+import { getDrugLabelActions } from "../../../tools/lib/openfda-client.js";
+function formatEffectiveTime(yyyymmdd) {
+    if (!yyyymmdd || yyyymmdd.length < 6)
+        return "";
+    return `${yyyymmdd.slice(0, 4)}-${yyyymmdd.slice(4, 6)}`;
+}
+function formatEmaDate(ddmmyyyy) {
+    if (!ddmmyyyy)
+        return "";
+    const parts = ddmmyyyy.split("/");
+    if (parts.length !== 3)
+        return "";
+    return `${parts[2]}-${parts[1]}`;
+}
+const FINDING_CHAR_LIMIT = 2000;
+function clipFinding(text) {
+    const cleaned = text.replace(/\s+/g, " ").trim();
+    if (cleaned.length <= FINDING_CHAR_LIMIT)
+        return cleaned;
+    return `${cleaned.slice(0, FINDING_CHAR_LIMIT - 1).trimEnd()}…`;
+}
+function fdaRowsFor(drug, labels) {
+    if (labels.length === 0)
+        return [];
+    const sorted = [...labels].sort((a, b) => (b.effectiveTime ?? "").localeCompare(a.effectiveTime ?? ""));
+    const latest = sorted[0];
+    const rows = [];
+    const actionDate = formatEffectiveTime(latest.effectiveTime);
+    if (latest.boxedWarning) {
+        rows.push({
+            drug_chembl_id: drug.chemblId,
+            drug_name: drug.name,
+            agency: "FDA",
+            action_kind: "black_box",
+            source_kind: "boxed_warning",
+            action_date: actionDate,
+            source_date: actionDate,
+            application_number: latest.applicationNumber ?? undefined,
+            finding: clipFinding(latest.boxedWarning),
+            source_url: latest.sourceUrl || undefined,
+            evidence: [],
+        });
+    }
+    if (latest.warningsAndCautions) {
+        rows.push({
+            drug_chembl_id: drug.chemblId,
+            drug_name: drug.name,
+            agency: "FDA",
+            action_kind: "label_warning",
+            source_kind: "label_warning",
+            action_date: actionDate,
+            source_date: actionDate,
+            application_number: latest.applicationNumber ?? undefined,
+            label_section: "5",
+            finding: clipFinding(latest.warningsAndCautions),
+            source_url: latest.sourceUrl || undefined,
+            evidence: [],
+        });
+    }
+    if (latest.hasRems) {
+        rows.push({
+            drug_chembl_id: drug.chemblId,
+            drug_name: drug.name,
+            agency: "FDA",
+            action_kind: "REMS",
+            source_kind: "rems",
+            action_date: actionDate,
+            source_date: actionDate,
+            application_number: latest.applicationNumber ?? undefined,
+            finding: `Risk Evaluation and Mitigation Strategy referenced in current label (${latest.brandName ?? latest.genericName ?? drug.name}).`,
+            source_url: latest.sourceUrl || undefined,
+            evidence: [],
+        });
+    }
+    return rows;
+}
+function classifyEmaActionKind(referral) {
+    const status = referral.currentStatus.toLowerCase();
+    if (status.includes("withdraw"))
+        return "withdrawal";
+    return "referral";
+}
+function emaRowsFor(drug, referrals) {
+    return referrals.map((r) => {
+        const date = formatEmaDate(r.europeanCommissionDecisionDate) ||
+            formatEmaDate(r.chmpOpinionDate) ||
+            formatEmaDate(r.cmdhPositionDate) ||
+            formatEmaDate(r.pracRecommendationDate) ||
+            formatEmaDate(r.procedureStartDate);
+        const findingParts = [];
+        if (r.referralType)
+            findingParts.push(r.referralType);
+        if (r.referenceNumber)
+            findingParts.push(`(${r.referenceNumber})`);
+        if (r.currentStatus)
+            findingParts.push(`— ${r.currentStatus}`);
+        if (r.referralName && r.referralName.toLowerCase() !== drug.name.toLowerCase()) {
+            findingParts.push(`re: ${r.referralName}`);
+        }
+        return {
+            drug_chembl_id: drug.chemblId,
+            drug_name: drug.name,
+            agency: "EMA",
+            action_kind: classifyEmaActionKind(r),
+            source_kind: classifyEmaActionKind(r) === "withdrawal" ? "withdrawal" : "referral",
+            action_date: date,
+            source_date: date,
+            finding: clipFinding(findingParts.join(" ")),
+            source_url: r.referralUrl || undefined,
+            evidence: [],
+        };
+    });
+}
+/**
+ * Fetch regulatory actions (FDA label + EMA referrals) for a set of drugs.
+ * Per-drug failures are isolated — one drug throwing does not blank out
+ * the rest. Returns an empty array when no drugs are provided or no source
+ * returned any actions.
+ */
+export async function fetchRegulatoryActions(drugs) {
+    if (drugs.length === 0)
+        return [];
+    const perDrug = await Promise.all(drugs.map(async (drug) => {
+        const [fdaLabels, emaReferrals] = await Promise.all([
+            withHost("openfda", () => getDrugLabelActions(drug.name)).catch(() => []),
+            withHost("ema", () => getReferralsByDrug(drug.name)).catch(() => []),
+        ]);
+        return [...fdaRowsFor(drug, fdaLabels), ...emaRowsFor(drug, emaReferrals)];
+    }));
+    return perDrug.flat();
+}

package/dist/workflows/target-assessment/lib/structured-llm.d.ts

@@ -0,0 +1,58 @@
+/**
+ * Structured-output LLM helper for the target-assessment DBOS workflow.
+ *
+ * Uses a tool-choice forcing pattern: a single Anthropic tool named `submit`
+ * carries the Zod schema as its `input_schema`, and
+ * `tool_choice: { type: "tool", name: "submit" }` forces the model to fill
+ * it. The tool's `input` IS the structured output.
+ *
+ * This intentionally does NOT pull in the harness `runAgent` loop — Phase-2
+ * decisions are zero-tool single-shot calls. Phase-5 syntheses today use
+ * regulatory-guidance + approval-precedent retrieval tools; the harness
+ * port drops those grounding tools (PR #4 ships single-shot synthesis; a
+ * follow-up may reintroduce the retrieval tools through the agent loop).
+ *
+ * Calls are routed through `runLlmStep`, so each LLM call lives in its own
+ * `DBOS.runStep({name})` cache slot and a billing-gateway 402 self-cancels the
+ * workflow rather than returning a coverage envelope.
+ */
+import { z } from "zod";
+import type { AgentSession } from "../../../auth/types.js";
+import type { AgentChat } from "../../../providers/types.js";
+import { BUDGET_EXCEEDED_SENTINEL } from "./llm-step.js";
+export interface StructuredLlmCallOptions<TSchema extends z.ZodType> {
+    /** Attempt-numbered durable-step name (e.g. `"ta-decision:modulator-triage:0"`). */
+    readonly stepName: string;
+    /** Agent id stamped on telemetry and billing-gateway provenance. */
+    readonly agentId: string;
+    readonly provider: AgentChat;
+    readonly session: AgentSession;
+    readonly system: string;
+    readonly prompt: string;
+    readonly schema: TSchema;
+    readonly model: string;
+    readonly signal?: AbortSignal;
+}
+export type StructuredLlmResult<TSchema extends z.ZodType> = {
+    readonly kind: "ok";
+    readonly value: z.infer<TSchema>;
+} | {
+    readonly kind: "budget-exceeded";
+    readonly sentinel: typeof BUDGET_EXCEEDED_SENTINEL;
+};
+/**
+ * Thrown when the model returned a structured-output payload that does
+ * not parse against the declared Zod schema. The caller decides whether
+ * to wrap as `coverage: "queried_no_data"` or rethrow as a hard failure.
+ */
+export declare class StructuredOutputParseError extends Error {
+    readonly cause?: unknown | undefined;
+    constructor(message: string, cause?: unknown | undefined);
+}
+/**
+ * Run one structured-output LLM call. Forces the model to call the
+ * `submit` tool whose input schema is `opts.schema`; parses the tool
+ * input via `safeParse` and returns the typed value. A billing-gateway 402 returns
+ * the budget-exceeded sentinel; non-402 throws + parse errors throw.
+ */
+export declare function structuredLlmCall<TSchema extends z.ZodType>(opts: StructuredLlmCallOptions<TSchema>): Promise<StructuredLlmResult<TSchema>>;