@inflexa-ai/harness 0.17.0 → 0.19.0

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

@@ -27,6 +27,7 @@ import { searchFailedTrials, searchTrialsForTarget } from "../../../tools/lib/cl
 import { filterInformative, searchClinvar } from "../../../tools/lib/clinvar-client.js";
 import { getKoPhenotypeProfile } from "../../../tools/lib/impc-client.js";
 import { getFamilyHeterodimers } from "../../../tools/lib/iuphar-client.js";
+import { getGenePhenotypeProfile } from "../../../tools/lib/monarch-client.js";
 import { getFaersByDrug, getFaersSeriousness } from "../../../tools/lib/openfda-client.js";
 import { getBaselineExpression, getTargetSafetyLiabilities, searchTargetAssociations } from "../../../tools/lib/opentargets-client.js";
 import { getPathwayMemberships } from "../../../tools/lib/pathway-client.js";
@@ -316,7 +317,48 @@ export async function collectImpc(input) {
         return fail(err);
     }
 }
-// ── 10. Open Targets ─────────────────────────────────────────────────
+// ── 10. Monarch Initiative ───────────────────────────────────────────
+export async function collectMonarch(input) {
+    // Monarch resolves prefixed identifiers; HGNC is its native gene namespace
+    // and NCBI Gene is the fallback it also indexes.
+    const geneCurie = input.ids.hgnc ?? (input.ids.entrez ? `NCBIGene:${input.ids.entrez}` : null);
+    if (!geneCurie) {
+        return {
+            coverage: "not_loaded",
+            reason: "no HGNC or NCBI Gene id resolved",
+        };
+    }
+    try {
+        const profile = await withHost("monarch", () => getGenePhenotypeProfile(geneCurie));
+        if (profile.phenotypes.length === 0) {
+            return {
+                coverage: "queried_no_data",
+                error: {
+                    message: `Monarch holds no human phenotype associations for ${geneCurie}`,
+                },
+            };
+        }
+        return {
+            coverage: "available",
+            data: {
+                geneCurie: profile.geneCurie,
+                phenotypes: profile.phenotypes.map((p) => ({
+                    hpoId: p.hpoId,
+                    label: p.label,
+                    ancestorIds: p.ancestorIds,
+                    publications: p.publications,
+                    diseaseContext: p.diseaseContext,
+                    frequencyPercent: p.frequencyPercent,
+                    primaryKnowledgeSource: p.primaryKnowledgeSource,
+                })),
+            },
+        };
+    }
+    catch (err) {
+        return fail(err);
+    }
+}
+// ── 11. Open Targets ─────────────────────────────────────────────────
 export async function collectOpenTargets(input) {
     const ensemblId = input.ids.ensembl;
     if (!ensemblId) {
@@ -351,7 +393,7 @@ export async function collectOpenTargets(input) {
         return fail(err);
     }
 }
-// ── 11. Pathways (Reactome + KEGG via the unified client) ────────────
+// ── 12. Pathways (Reactome + KEGG via the unified client) ────────────
 export async function collectPathways(input) {
     try {
         const raw = await withHost("reactome", () => getPathwayMemberships(input.geneSymbol));
@@ -380,7 +422,7 @@ export async function collectPathways(input) {
         return fail(err);
     }
 }
-// ── 12. PubMed index ─────────────────────────────────────────────────
+// ── 13. PubMed index ─────────────────────────────────────────────────
 export async function collectPubmedIndex(input, ctx) {
     const query = `"${input.geneSymbol}"[Gene]`;
     try {
@@ -407,7 +449,7 @@ export async function collectPubmedIndex(input, ctx) {
         return fail(err);
     }
 }
-// ── 13. STRING PPI ───────────────────────────────────────────────────
+// ── 14. STRING PPI ───────────────────────────────────────────────────
 export async function collectStringPpi(input) {
     try {
         const partners = await withHost("string", () => getInteractionPartners([input.geneSymbol], {
@@ -429,7 +471,7 @@ export async function collectStringPpi(input) {
         return fail(err);
     }
 }
-// ── 14. Therapeutic programs (non-ChEMBL curated set) ────────────────
+// ── 15. Therapeutic programs (non-ChEMBL curated set) ────────────────
 export async function collectTherapeuticPrograms(input) {
     const programs = findTherapeuticProgramsForTarget({
         geneSymbol: input.geneSymbol,
@@ -460,6 +502,7 @@ export const COLLECTOR_MANIFEST = [
     { id: "faers-by-target", run: collectFaersByTarget },
     { id: "family-complexes", run: collectFamilyComplexes },
     { id: "impc", run: collectImpc },
+    { id: "monarch", run: collectMonarch },
     { id: "opentargets", run: collectOpenTargets },
     { id: "pathways", run: collectPathways },
     { id: "pubmed-index", run: collectPubmedIndex },

package/dist/workflows/target-assessment/coverage.d.ts

@@ -6,29 +6,19 @@
  * instead of throwing. Only Phase 0 (target resolution) is allowed to
  * throw — that legitimately aborts the workflow.
  *
- * Coverage states:
- *   - "available"        — the upstream returned data; payload is present.
- *   - "queried_no_data"  — the upstream was queried but came back empty
- *                          (no rows / 404 / etc.) OR threw an error which
- *                          we serialized into `error` instead of bubbling.
- *   - "not_loaded"       — the upstream was never queried (feature flag,
- *                          config disable, or upstream skipped because a
- *                          precondition was not met).
+ * `CoverageSchema` in `contracts/target-dossier.ts` is the one enumeration of
+ * the coverage states, and the helpers below emit its members. A step envelope
+ * carries the three states a step can reach on its own; `filtered` is a
+ * judgement one of our own filters makes, so only the assembler helpers below
+ * produce it.
  */
 import { z } from "zod";
-export declare const CoverageSchema: z.ZodEnum<{
-    available: "available";
-    queried_no_data: "queried_no_data";
-    not_loaded: "not_loaded";
-}>;
-export type Coverage = z.infer<typeof CoverageSchema>;
 export declare const SerializedErrorSchema: z.ZodObject<{
     message: z.ZodString;
     name: z.ZodOptional<z.ZodString>;
     stack: z.ZodOptional<z.ZodString>;
 }, z.core.$strip>;
 export type SerializedError = z.infer<typeof SerializedErrorSchema>;
-export declare function serializeError(err: unknown): SerializedError;
 /**
  * Build the schema for a `{ coverage, data, error? }` step output.
  *
@@ -49,18 +39,6 @@ export declare function withCoverage<TData extends z.ZodTypeAny>(dataSchema: TDa
     coverage: z.ZodLiteral<"not_loaded">;
     reason: z.ZodOptional<z.ZodString>;
 }, z.core.$strip>], "coverage">;
-/**
- * Run a step body with the standard try/catch envelope. If the body
- * resolves, returns `{ coverage: "available", data }`. If it throws,
- * returns `{ coverage: "queried_no_data", error: serializeError(err) }`.
- */
-export declare function runWithCoverage<T>(body: () => Promise<T>): Promise<{
-    coverage: "available";
-    data: T;
-} | {
-    coverage: "queried_no_data";
-    error: SerializedError;
-}>;
 /**
  * Convenience wrapper for `{ rows: T[] }` payloads. Maps an empty rows
  * array to `coverage: "queried_no_data"` so the dossier discriminator's
@@ -79,3 +57,41 @@ export declare function coverageFromRows<T>(rows: T[], opts?: {
     coverage: "queried_no_data";
     error: SerializedError;
 };
+/**
+ * Build a dossier-section envelope for a row list one of our own filters
+ * narrowed.
+ *
+ * A filter is not the same as an empty upstream, and the difference is the
+ * whole point of the four-state contract. Deciding coverage from the source
+ * and then filtering the payload loses it: a section whose every row our
+ * threshold discarded reports a clean `available` holding nothing, which reads
+ * as "the source had nothing to say".
+ *
+ * So the decision is made once, from both counts:
+ *   - nothing survived and something was dropped → `filtered`, naming the
+ *     filter and the count it discarded, with no `data`;
+ *   - some survived and some were dropped → `available` carrying
+ *     `dropped_count`, so the section does not overstate its completeness;
+ *   - nothing survived and nothing was dropped → `queried_no_data`: the list
+ *     was empty before any filter of ours ran.
+ */
+export declare function coverageFromFilteredRows<TData>(args: {
+    data: TData;
+    retainedCount: number;
+    droppedCount: number;
+    /** What ran, in a reader's terms — carried verbatim on the `filtered` branch. */
+    filter: string;
+    /** Why the source itself held nothing, used only when no filter dropped anything. */
+    emptyReason: string;
+}): {
+    coverage: "available";
+    data: TData;
+    dropped_count?: number;
+} | {
+    coverage: "filtered";
+    filter: string;
+    dropped_count: number;
+} | {
+    coverage: "queried_no_data";
+    error: SerializedError;
+};

package/dist/workflows/target-assessment/coverage.js

@@ -6,28 +6,18 @@
  * instead of throwing. Only Phase 0 (target resolution) is allowed to
  * throw — that legitimately aborts the workflow.
  *
- * Coverage states:
- *   - "available"        — the upstream returned data; payload is present.
- *   - "queried_no_data"  — the upstream was queried but came back empty
- *                          (no rows / 404 / etc.) OR threw an error which
- *                          we serialized into `error` instead of bubbling.
- *   - "not_loaded"       — the upstream was never queried (feature flag,
- *                          config disable, or upstream skipped because a
- *                          precondition was not met).
+ * `CoverageSchema` in `contracts/target-dossier.ts` is the one enumeration of
+ * the coverage states, and the helpers below emit its members. A step envelope
+ * carries the three states a step can reach on its own; `filtered` is a
+ * judgement one of our own filters makes, so only the assembler helpers below
+ * produce it.
  */
 import { z } from "zod";
-export const CoverageSchema = z.enum(["available", "queried_no_data", "not_loaded"]);
 export const SerializedErrorSchema = z.object({
     message: z.string(),
     name: z.string().optional(),
     stack: z.string().optional(),
 });
-export function serializeError(err) {
-    if (err instanceof Error) {
-        return { message: err.message, name: err.name, stack: err.stack };
-    }
-    return { message: String(err) };
-}
 /**
  * Build the schema for a `{ coverage, data, error? }` step output.
  *
@@ -50,20 +40,6 @@ export function withCoverage(dataSchema) {
         }),
     ]);
 }
-/**
- * Run a step body with the standard try/catch envelope. If the body
- * resolves, returns `{ coverage: "available", data }`. If it throws,
- * returns `{ coverage: "queried_no_data", error: serializeError(err) }`.
- */
-export async function runWithCoverage(body) {
-    try {
-        const data = await body();
-        return { coverage: "available", data };
-    }
-    catch (err) {
-        return { coverage: "queried_no_data", error: serializeError(err) };
-    }
-}
 /**
  * Convenience wrapper for `{ rows: T[] }` payloads. Maps an empty rows
  * array to `coverage: "queried_no_data"` so the dossier discriminator's
@@ -80,3 +56,31 @@ export function coverageFromRows(rows, opts) {
     }
     return { coverage: "available", data: { rows } };
 }
+/**
+ * Build a dossier-section envelope for a row list one of our own filters
+ * narrowed.
+ *
+ * A filter is not the same as an empty upstream, and the difference is the
+ * whole point of the four-state contract. Deciding coverage from the source
+ * and then filtering the payload loses it: a section whose every row our
+ * threshold discarded reports a clean `available` holding nothing, which reads
+ * as "the source had nothing to say".
+ *
+ * So the decision is made once, from both counts:
+ *   - nothing survived and something was dropped → `filtered`, naming the
+ *     filter and the count it discarded, with no `data`;
+ *   - some survived and some were dropped → `available` carrying
+ *     `dropped_count`, so the section does not overstate its completeness;
+ *   - nothing survived and nothing was dropped → `queried_no_data`: the list
+ *     was empty before any filter of ours ran.
+ */
+export function coverageFromFilteredRows(args) {
+    const { data, retainedCount, droppedCount, filter, emptyReason } = args;
+    if (retainedCount > 0) {
+        return droppedCount > 0 ? { coverage: "available", data, dropped_count: droppedCount } : { coverage: "available", data };
+    }
+    if (droppedCount > 0) {
+        return { coverage: "filtered", filter, dropped_count: droppedCount };
+    }
+    return { coverage: "queried_no_data", error: { message: emptyReason } };
+}

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

@@ -85,6 +85,7 @@ export async function polypharmForOneModulator(item) {
                 hits: hits.map((h) => ({
                     targetChemblId: h.targetChemblId,
                     targetName: h.targetName,
+                    assayChemblId: h.assayChemblId,
                     pchemblValue: h.pchemblValue,
                     standardType: h.standardType,
                     standardValue: h.standardValue,

package/dist/workflows/target-assessment/investigation/index.d.ts

@@ -0,0 +1,97 @@
+/**
+ * The claim-investigation phase.
+ *
+ * Corroboration says which organs several sources agree on. Agreement is not
+ * adjudication: sources that all re-import one curation agree perfectly and are
+ * wrong together. This phase interrogates each corroborated organ claim —
+ * propose a mechanism, argue against it, re-verify, converge — and records what
+ * survived, plus every candidate it did not get to and why.
+ *
+ * Three LLM steps per round, chosen per step rather than uniformly:
+ *
+ *   - **propose** and **re-verify** are single-shot structured extractions
+ *     (`structuredLlmCall`). Everything they reason over is already in the
+ *     prompt; a retrieval surface would only let them ground an answer in
+ *     something the run never collected.
+ *   - **critique** is a real agent loop (`runToTerminal` over `runAgent`) with a
+ *     literature tool and a `defineTool` terminal recorder. Disconfirmation is a
+ *     search task: the dossier is assembled to state what the run found, not to
+ *     refute it, so a critic confined to it can only observe that the evidence
+ *     is thin — which is the rubber stamp this step exists to avoid.
+ *
+ * Nothing here scores a claim. The verdict is a four-word vocabulary the model
+ * states, no threshold decides survival, and no claim is removed from the
+ * dossier by anything this phase concludes.
+ *
+ * Durability arrives through the injected `runStep` seam and through
+ * `structuredLlmCall`'s own attempt-named steps; this module imports no
+ * durability engine.
+ */
+import type { ClaimInvestigation, DossierBody, SafetyCorroboration } from "@inflexa-ai/harness/contracts/target-dossier.js";
+import type { AgentSession } from "../../../auth/types.js";
+import type { UsageRecorder } from "../../../billing/usage-recorder.js";
+import type { Logger } from "../../../lib/logger.js";
+import type { RunStep } from "../../../loop/types.js";
+import type { AgentChat } from "../../../providers/types.js";
+import { type Tool } from "../../../tools/define-tool.js";
+import { BUDGET_EXCEEDED_SENTINEL } from "../lib/llm-step.js";
+/**
+ * The bounds the phase runs under.
+ *
+ * These are configuration with stated defaults, not clinical constants: nothing
+ * about biology says six claims or two rounds. They exist to bound cost and to
+ * guarantee termination, the section reports the values in force, and an
+ * embedder that wants a deeper pass sets its own.
+ */
+export interface ClaimInvestigationConfig {
+    /** Corroborated organ claims investigated per run; the rest are reported as budget-cut. */
+    readonly claimBudget: number;
+    /** Propose → critique → re-verify rounds a single claim may run. */
+    readonly roundBound: number;
+    /** Iteration budget for the adversarial critic's tool-using loop. */
+    readonly criticMaxIterations: number;
+}
+export declare const DEFAULT_CLAIM_INVESTIGATION_CONFIG: ClaimInvestigationConfig;
+export interface ClaimInvestigationDeps {
+    /** Operational logging seam; omitted falls back to no-op. */
+    readonly logger?: Logger;
+    readonly chatProvider: AgentChat;
+    /** Session for the phase; each step derives its own sub-agent session from it. */
+    readonly session: AgentSession;
+    readonly model: string;
+    /** Attempt counter — bumped on resume so a cancelled call lands a fresh durable slot. */
+    readonly attempt: number;
+    /** Durability seam for the critic's agent loop. */
+    readonly runStep: RunStep;
+    /** Retrieval surface the adversarial critic searches for disconfirming records. */
+    readonly critiqueTools: readonly Tool[];
+    /** Overrides for {@link DEFAULT_CLAIM_INVESTIGATION_CONFIG}. */
+    readonly config?: Partial<ClaimInvestigationConfig>;
+    /** LLM usage-accounting seam for the critic loop; omitted falls back to the no-op recorder. */
+    readonly usageRecorder?: UsageRecorder;
+    readonly signal?: AbortSignal;
+}
+export interface ClaimInvestigationInput {
+    /** The run's corroboration record — the source of candidate claims. */
+    readonly corroboration: SafetyCorroboration;
+    /** The assembled dossier body, read for per-organ risk context and completeness. */
+    readonly dossier: DossierBody;
+}
+/** The sentinel an LLM step returns once it has self-cancelled the workflow on a 402. */
+export interface BudgetExceeded {
+    readonly kind: "budget-exceeded";
+    readonly sentinel: typeof BUDGET_EXCEEDED_SENTINEL;
+}
+export type ClaimInvestigationResult = ClaimInvestigation | BudgetExceeded;
+declare function isBudgetCancel<T>(value: T | BudgetExceeded): value is BudgetExceeded;
+/**
+ * Interrogate the run's corroborated organ claims.
+ *
+ * Coverage is the honest account of what happened: `not_loaded` when there was
+ * no corroboration record to work from, `queried_no_data` when the fold produced
+ * no corroborated organ, and `available` once at least one candidate reached the
+ * phase — including when every one of them ended up in `not_investigated`, since
+ * that list is what the section has to say in that case.
+ */
+export declare function investigateClaims(input: ClaimInvestigationInput, deps: ClaimInvestigationDeps): Promise<ClaimInvestigationResult>;
+export { isBudgetCancel as isClaimInvestigationBudgetExceeded };