@inflexa-ai/harness 0.35.8 → 0.36.1

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

@@ -1,538 +0,0 @@
-/**
- * Phase-1 collector functions for the harness DBOS workflow.
- *
- * Each collector is a pure async function `(input: ResolvedTarget) =>
- * Promise<CoverageBundle>`. Bodies: try/catch wraps a `withHost`-
- * guarded tool-client call (or a couple in parallel) and returns
- * `{coverage: "available", data}` on success or `{coverage: "queried_no_data",
- * error}` on failure. A handful of collectors return
- * `{coverage: "not_loaded", reason}` when a required upstream identifier is
- * missing — that signals "we never tried" vs. "we tried and got nothing."
- *
- * No collector throws — coverage is the failure mode. The DBOS workflow body
- * wraps each call in `DBOS.runStep({name: "ta-collector:{collectorId}"})` so
- * recovery on a fresh replica replays the cached coverage envelope instead
- * of re-issuing the HTTP call.
- *
- * No `deps` parameter is threaded through today (collectors call the tool
- * clients directly) — every external request goes through the global
- * `withHost(...)` semaphore. The function signature reserves the future
- * `deps` slot for test injection without churning callers.
- */
-import { createNoopLogger } from "../../../lib/console-logger.js";
-import { withHost } from "../../../lib/host-concurrency.js";
-import { getMultiSpeciesExpression } from "../../../tools/lib/bgee-client.js";
-import { getSomaticMutationFrequencies } from "../../../tools/lib/cbioportal-client.js";
-import { getModulatorsViaActivity, getTargetModulators } from "../../../tools/lib/chembl-client.js";
-import { searchFailedTrials, searchTrialsForTarget } from "../../../tools/lib/clinical-trials-client.js";
-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";
-import { searchPubmed } from "../../../tools/lib/pubmed-client.js";
-import { getInteractionPartners } from "../../../tools/lib/string-client.js";
-import { findTherapeuticProgramsForTarget } from "../lib/therapeutic-programs.js";
-import { dedupPathwaysAcrossSpecies } from "../steps/collectors/pathways.js";
-function fail(err) {
-    return {
-        coverage: "queried_no_data",
-        error: { message: err instanceof Error ? err.message : String(err) },
-    };
-}
-// ── 1. cBioPortal ────────────────────────────────────────────────────
-export async function collectCbioportal(input) {
-    try {
-        const result = await withHost("cbioportal", () => getSomaticMutationFrequencies(input.geneSymbol));
-        if (result.entrezGeneId == null) {
-            return {
-                coverage: "queried_no_data",
-                error: {
-                    message: `cBioPortal could not resolve Entrez id for ${input.geneSymbol}`,
-                },
-            };
-        }
-        return { coverage: "available", data: result };
-    }
-    catch (err) {
-        return fail(err);
-    }
-}
-// ── 2. ChEMBL modulators ─────────────────────────────────────────────
-export async function collectChemblModulators(input, ctx) {
-    const chemblId = input.ids.chembl;
-    if (!chemblId) {
-        return { coverage: "not_loaded", reason: "no ChEMBL target id resolved" };
-    }
-    try {
-        const primaryRows = await withHost("chembl", () => getTargetModulators(chemblId, { minPhase: 2, limit: 200 }, ctx.logger));
-        const activityRows = await withHost("chembl", () => getModulatorsViaActivity({
-            target_chembl_id: chemblId,
-            max_phase_min: 2,
-            molecule_type: "Small molecule",
-        }, ctx.logger));
-        const primaryIds = new Set(primaryRows.map((m) => m.moleculeChemblId));
-        const novelActivityRows = activityRows
-            .filter((m) => !primaryIds.has(m.moleculeChemblId))
-            .map((m) => ({ ...m, evidence_source: "chembl_activity" }));
-        const modulators = [...primaryRows, ...novelActivityRows];
-        return {
-            coverage: "available",
-            data: { targetChemblId: chemblId, modulators },
-        };
-    }
-    catch (err) {
-        return fail(err);
-    }
-}
-// ── 3. ClinVar ───────────────────────────────────────────────────────
-export async function collectClinvar(input, ctx) {
-    try {
-        const result = await withHost("ncbi", () => searchClinvar(ctx.ncbiApiKey, input.geneSymbol, { limit: 200 }));
-        const filtered = filterInformative(result.variants);
-        return {
-            coverage: "available",
-            data: {
-                totalFound: result.totalFound,
-                variants: filtered.map((v) => ({
-                    variationId: v.variationId,
-                    title: v.title,
-                    clinicalSignificance: v.clinicalSignificance,
-                    reviewStatus: v.reviewStatus,
-                    conditions: v.conditions,
-                    molecularConsequence: v.molecularConsequence,
-                    accession: v.accession,
-                })),
-            },
-        };
-    }
-    catch (err) {
-        return fail(err);
-    }
-}
-// ── 4. ClinicalTrials.gov ────────────────────────────────────────────
-function tagTrials(trials, collection_query, collection_channel) {
-    return trials.map((trial) => ({
-        ...trial,
-        collection_query,
-        collection_channel,
-    }));
-}
-export async function collectCtgov(input) {
-    try {
-        const [active, failed] = await Promise.all([
-            withHost("ctgov", () => searchTrialsForTarget(input.geneSymbol, { limit: 100 })),
-            withHost("ctgov", () => searchFailedTrials(input.geneSymbol, 100)),
-        ]);
-        return {
-            coverage: "available",
-            data: {
-                active: tagTrials(active.trials, input.geneSymbol, "target_symbol"),
-                failed: tagTrials(failed.trials, input.geneSymbol, "failed_intervention"),
-            },
-        };
-    }
-    catch (err) {
-        return fail(err);
-    }
-}
-// ── 5. Expression — human (Open Targets baseline) ────────────────────
-export async function collectExpressionHuman(input) {
-    const ensemblId = input.ids.ensembl;
-    if (!ensemblId) {
-        return { coverage: "not_loaded", reason: "no Ensembl id resolved" };
-    }
-    try {
-        const expressions = await withHost("opentargets", () => getBaselineExpression(ensemblId));
-        if (expressions.length === 0) {
-            return {
-                coverage: "queried_no_data",
-                error: {
-                    message: `Open Targets returned no baseline expression for ${ensemblId}`,
-                },
-            };
-        }
-        // `baselineExpression` mixes datasources under one row type, and each one
-        // carries its own unit: GTEx gives bulk-tissue TPM, Tabula Sapiens gives
-        // single-cell CPM pseudobulk, and DICE gives immune-cell TPM. The bundle
-        // declares one source and one unit, thus it can hold rows of one datasource
-        // only. Tabula Sapiens also outnumbers GTEx about 20 to 1, thus an unfiltered
-        // list drowns the tissue table in cell types.
-        const gtex = expressions.filter((e) => e.datasourceId === "gtex");
-        if (gtex.length === 0) {
-            return {
-                coverage: "queried_no_data",
-                error: {
-                    message: `Open Targets carries no GTEx baseline expression for ${ensemblId} (${expressions.length} rows of other datasources dropped)`,
-                },
-            };
-        }
-        const tissues = gtex.map((e) => ({
-            tissueLabel: e.tissueLabel,
-            organSystem: e.organSystem,
-            value: e.rna?.value ?? null,
-        }));
-        return {
-            coverage: "available",
-            data: {
-                source: "gtex",
-                unit: "tpm",
-                normalization_notes: "Open Targets baseline expression, GTEx bulk-tissue rows only, as the median TPM of each tissue",
-                tissues,
-            },
-        };
-    }
-    catch (err) {
-        return fail(err);
-    }
-}
-// ── 6. Expression — multi-species (Bgee) ─────────────────────────────
-export async function collectExpressionMultiSpecies(input) {
-    try {
-        const result = await withHost("bgee", () => getMultiSpeciesExpression(input.geneSymbol));
-        if (!result.humanEnsemblId) {
-            return {
-                coverage: "queried_no_data",
-                error: {
-                    message: `Bgee could not resolve Ensembl id for ${input.geneSymbol}`,
-                },
-            };
-        }
-        return {
-            coverage: "available",
-            data: {
-                geneSymbol: result.geneSymbol,
-                humanEnsemblId: result.humanEnsemblId,
-                bySpecies: result.bySpecies.map((s) => ({
-                    species: s.species,
-                    taxonId: s.taxonId,
-                    ensemblId: s.ensemblId,
-                    source: "bgee",
-                    unit: "expression_score",
-                    normalization_notes: "Bgee expression score (0–100) bucketed into absent/low/medium/high; not a transcript-abundance unit",
-                    tissues: s.tissues.map((t) => ({
-                        tissue: t.tissue,
-                        rank: t.rank,
-                        expressionScore: t.expressionScore,
-                    })),
-                })),
-                notFound: result.notFound,
-            },
-        };
-    }
-    catch (err) {
-        return fail(err);
-    }
-}
-// ── 7. FAERS by target ───────────────────────────────────────────────
-export async function collectFaersByTarget(input) {
-    const probe = input.geneSymbol;
-    try {
-        const [byDrug, seriousness] = await Promise.all([
-            withHost("openfda", () => getFaersByDrug(probe, { limit: 25 })),
-            withHost("openfda", () => getFaersSeriousness(probe)),
-        ]);
-        const total = byDrug.totalReports ?? 0;
-        if (total === 0 && byDrug.adverseEvents.length === 0) {
-            return {
-                coverage: "queried_no_data",
-                error: { message: `FAERS returned no reports for symbol ${probe}` },
-            };
-        }
-        return {
-            coverage: "available",
-            data: {
-                drugProbed: probe,
-                totalReports: byDrug.totalReports ?? null,
-                topReactions: byDrug.adverseEvents,
-                seriousness,
-            },
-        };
-    }
-    catch (err) {
-        return fail(err);
-    }
-}
-// ── 8. Family complexes (IUPHAR) ─────────────────────────────────────
-export async function collectFamilyComplexes(input, ctx) {
-    const geneSymbol = input.geneSymbol;
-    const uniprot = input.ids.uniprot;
-    const lookup = uniprot ?? geneSymbol;
-    if (!lookup) {
-        return {
-            coverage: "not_loaded",
-            reason: "no gene symbol or UniProt accession",
-        };
-    }
-    try {
-        const heterodimers = await withHost("iuphar", () => getFamilyHeterodimers(lookup));
-        if (heterodimers.length === 0) {
-            return {
-                coverage: "queried_no_data",
-                error: {
-                    message: `IUPHAR returned no heterodimer complexes for ${lookup}`,
-                },
-            };
-        }
-        const accessorySet = new Set();
-        const complexes = heterodimers.map((h) => {
-            const accessoryNames = h.accessories.map((a) => a.name).filter(Boolean);
-            for (const n of accessoryNames)
-                accessorySet.add(n);
-            return {
-                complexName: h.complex.name,
-                complexId: h.complex.targetId,
-                accessoryNames,
-                subunitNames: h.subunits.map((s) => s.name).filter(Boolean),
-            };
-        });
-        return {
-            coverage: "available",
-            data: {
-                primaryTargetGene: geneSymbol,
-                primaryTargetUniprot: uniprot,
-                accessoryProteinNames: [...accessorySet].sort(),
-                complexes,
-            },
-        };
-    }
-    catch (err) {
-        // `getFamilyHeterodimers` answers an unknown target with an empty list, thus
-        // a throw here is always an unexpected cause. The IUPHAR outage of 2026 hid
-        // behind this envelope for months, because `queried_no_data` reads as a
-        // clean miss to every consumer of the dossier.
-        const log = (ctx.logger ?? createNoopLogger()).named("ta-collector.family-complexes");
-        log.error("IUPHAR family-complex lookup failed", { lookup, ...log.errorFields(err) });
-        return fail(err);
-    }
-}
-// ── 9. IMPC ───────────────────────────────────────────────────────────
-export async function collectImpc(input) {
-    try {
-        const profile = await withHost("ncbi", () => getKoPhenotypeProfile(input.geneSymbol));
-        if (!profile.mouseMarkerSymbol) {
-            return {
-                coverage: "queried_no_data",
-                error: {
-                    message: `IMPC has no mouse marker for ${input.geneSymbol}`,
-                },
-            };
-        }
-        return {
-            coverage: "available",
-            data: {
-                mouseMarkerSymbol: profile.mouseMarkerSymbol,
-                mgiAccessionId: profile.mgiAccessionId,
-                viability: profile.viability,
-                viabilityCalls: profile.viabilityCalls,
-                mpTerms: profile.mpTerms,
-                organSystems: profile.organSystems,
-                sexDimorphic: profile.sexDimorphic,
-                phenotypeCount: profile.phenotypeCount,
-            },
-        };
-    }
-    catch (err) {
-        return fail(err);
-    }
-}
-// ── 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) {
-        return { coverage: "not_loaded", reason: "no Ensembl id resolved" };
-    }
-    try {
-        const [info, safety, expression] = await Promise.all([
-            withHost("opentargets", () => searchTargetAssociations(ensemblId, 50)),
-            withHost("opentargets", () => getTargetSafetyLiabilities(ensemblId)),
-            withHost("opentargets", () => getBaselineExpression(ensemblId)),
-        ]);
-        if (!info) {
-            return {
-                coverage: "queried_no_data",
-                error: { message: `no Open Targets entry for ${ensemblId}` },
-            };
-        }
-        return {
-            coverage: "available",
-            data: {
-                ensemblId: info.ensemblId,
-                approvedSymbol: info.approvedSymbol,
-                approvedName: info.approvedName,
-                tractability: info.tractability,
-                associations: info.associations,
-                safetyLiabilities: safety?.safetyLiabilities ?? [],
-                baselineExpression: expression.map((e) => ({
-                    tissueId: e.tissueId,
-                    tissueLabel: e.tissueLabel,
-                    organSystem: e.organSystem,
-                    datasourceId: e.datasourceId,
-                    rna: e.rna,
-                })),
-            },
-        };
-    }
-    catch (err) {
-        return fail(err);
-    }
-}
-// ── 12. Pathways (Reactome + KEGG via the unified client) ────────────
-export async function collectPathways(input) {
-    try {
-        const raw = await withHost("reactome", () => getPathwayMemberships(input.geneSymbol));
-        const rows = raw.map((p) => ({
-            id: p.id,
-            name: p.name,
-            source: p.source,
-            url: p.url ?? "",
-            entity_uniprots: p.entity_uniprots,
-        }));
-        const cleaned = dedupPathwaysAcrossSpecies(rows, {
-            geneSymbolEchoFilter: input.geneSymbol,
-            assessmentUniprot: input.ids.uniprot ?? undefined,
-        });
-        if (cleaned.length === 0) {
-            return {
-                coverage: "queried_no_data",
-                error: {
-                    message: `KEGG and Reactome returned no pathways for ${input.geneSymbol}`,
-                },
-            };
-        }
-        return { coverage: "available", data: { pathways: cleaned } };
-    }
-    catch (err) {
-        return fail(err);
-    }
-}
-// ── 13. PubMed index ─────────────────────────────────────────────────
-export async function collectPubmedIndex(input, ctx) {
-    const query = `"${input.geneSymbol}"[Gene]`;
-    try {
-        const result = await withHost("ncbi", () => searchPubmed(ctx.ncbiApiKey, query, {
-            maxResults: 50,
-            sort: "relevance",
-        }));
-        if (result.totalFound === 0) {
-            return {
-                coverage: "queried_no_data",
-                error: { message: `PubMed returned no hits for ${query}` },
-            };
-        }
-        return {
-            coverage: "available",
-            data: {
-                totalFound: result.totalFound,
-                topPmids: result.results.map((r) => r.pmid),
-                results: result.results,
-            },
-        };
-    }
-    catch (err) {
-        return fail(err);
-    }
-}
-// ── 14. STRING PPI ───────────────────────────────────────────────────
-export async function collectStringPpi(input) {
-    try {
-        const partners = await withHost("string", () => getInteractionPartners([input.geneSymbol], {
-            species: 9606,
-            minScore: 400,
-            limit: 50,
-        }));
-        if (partners.length === 0) {
-            return {
-                coverage: "queried_no_data",
-                error: {
-                    message: `STRING returned no partners for ${input.geneSymbol}`,
-                },
-            };
-        }
-        return { coverage: "available", data: { partners } };
-    }
-    catch (err) {
-        return fail(err);
-    }
-}
-// ── 15. Therapeutic programs (non-ChEMBL curated set) ────────────────
-export async function collectTherapeuticPrograms(input) {
-    const programs = findTherapeuticProgramsForTarget({
-        geneSymbol: input.geneSymbol,
-        uniprot: input.ids.uniprot ?? null,
-    });
-    if (programs.length === 0) {
-        return {
-            coverage: "queried_no_data",
-            error: { message: "no non-ChEMBL therapeutic programs registered" },
-        };
-    }
-    return { coverage: "available", data: { programs } };
-}
-// ── Manifest ─────────────────────────────────────────────────────────
-/**
- * Stable id used as the durable-step name suffix —
- * `ta-collector:{collectorId}`. The DBOS workflow body iterates this
- * manifest so adding a collector is one entry here + one new exported
- * function above, with no scheduler edits.
- */
-export const COLLECTOR_MANIFEST = [
-    { id: "cbioportal", run: collectCbioportal },
-    { id: "chembl-modulators", run: collectChemblModulators },
-    { id: "clinvar", run: collectClinvar },
-    { id: "ctgov", run: collectCtgov },
-    { id: "expression-human", run: collectExpressionHuman },
-    { id: "expression-multi-species", run: collectExpressionMultiSpecies },
-    { 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 },
-    { id: "string-ppi", run: collectStringPpi },
-    { id: "therapeutic-programs", run: collectTherapeuticPrograms },
-];

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

@@ -1,97 +0,0 @@
-/**
- * Shared coverage discriminator for target-assessment workflow steps.
- *
- * Per design §6, every collector / decision / fan-out / synthesis step
- * MUST wrap its body in try/catch and return a `{ coverage, ... }` shape
- * instead of throwing. Only Phase 0 (target resolution) is allowed to
- * throw — that legitimately aborts the workflow.
- *
- * `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 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>;
-/**
- * Build the schema for a `{ coverage, data, error? }` step output.
- *
- * Use as: `outputSchema: withCoverage(MyDataSchema)` where `MyDataSchema`
- * is the shape of the Phase-1 / Phase-2 / etc. payload for this step.
- */
-export declare function withCoverage<TData extends z.ZodTypeAny>(dataSchema: TData): z.ZodDiscriminatedUnion<[z.ZodObject<{
-    coverage: z.ZodLiteral<"available">;
-    data: TData;
-}, z.core.$strip>, z.ZodObject<{
-    coverage: z.ZodLiteral<"queried_no_data">;
-    error: z.ZodOptional<z.ZodObject<{
-        message: z.ZodString;
-        name: z.ZodOptional<z.ZodString>;
-        stack: z.ZodOptional<z.ZodString>;
-    }, z.core.$strip>>;
-}, z.core.$strip>, z.ZodObject<{
-    coverage: z.ZodLiteral<"not_loaded">;
-    reason: z.ZodOptional<z.ZodString>;
-}, z.core.$strip>], "coverage">;
-/**
- * Convenience wrapper for `{ rows: T[] }` payloads. Maps an empty rows
- * array to `coverage: "queried_no_data"` so the dossier discriminator's
- * "available ≡ we have data" invariant holds without per-callsite
- * length checks. Use at any assembler callsite that emits a `rows`
- * shape from a query that may legitimately return zero items.
- */
-export declare function coverageFromRows<T>(rows: T[], opts?: {
-    reason?: string;
-}): {
-    coverage: "available";
-    data: {
-        rows: T[];
-    };
-} | {
-    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;
-};