@inflexa-ai/harness 0.1.1 → 0.2.0

package/dist/tools/bio/search-ctx-hazard.js

@@ -1,178 +0,0 @@
-/**
- * searchCtxHazard — search EPA CTX Hazard APIs (ToxValDB, ToxRefDB) for
- * toxicological hazard data on a chemical.
- */
-import { ok } from "neverthrow";
-import { z } from "zod";
-import { defineTool } from "../define-tool.js";
-import { apiFetchValidated, describeApiError } from "../lib/api-utils.js";
-import { EPA_CCTE_BASE, getEpaCcteHeaders } from "../lib/toxcast-config.js";
-// Each schema below both validates one raw CTX hazard row and normalizes it
-// into the curated output shape via `.transform`; `z.infer` is that output
-// type. Every wire field is optional (the API omits absent values); the two
-// numeric fields the API sends as string-or-number stay `z.unknown()` so
-// `toNumberOrNull` can coerce them without the schema rejecting the row.
-const ToxValSchema = z
-    .object({
-    source: z.string().nullable().optional(),
-    toxvalType: z.string().nullable().optional(),
-    toxvalNumeric: z.unknown().optional(),
-    toxvalUnits: z.string().nullable().optional(),
-    studyType: z.string().nullable().optional(),
-    studyDurationClass: z.string().nullable().optional(),
-    speciesCommon: z.string().nullable().optional(),
-    exposureRoute: z.string().nullable().optional(),
-    toxicologicalEffect: z.string().nullable().optional(),
-    riskAssessmentClass: z.string().nullable().optional(),
-    humanEco: z.string().nullable().optional(),
-    year: z.unknown().optional(),
-    quality: z.string().nullable().optional(),
-})
-    .transform((r) => ({
-    source: r.source ?? "",
-    toxvalType: r.toxvalType ?? "",
-    toxvalNumeric: toNumberOrNull(r.toxvalNumeric),
-    toxvalUnits: r.toxvalUnits ?? "",
-    studyType: r.studyType ?? "",
-    studyDurationClass: r.studyDurationClass ?? "",
-    species: r.speciesCommon ?? "",
-    exposureRoute: r.exposureRoute ?? "",
-    toxicologicalEffect: r.toxicologicalEffect ?? "",
-    riskAssessmentClass: r.riskAssessmentClass ?? "",
-    humanEco: r.humanEco ?? "",
-    year: toNumberOrNull(r.year),
-    quality: r.quality ?? "",
-}));
-const GenetoxSchema = z
-    .object({
-    source: z.string().nullable().optional(),
-    assayCategory: z.string().nullable().optional(),
-    assayType: z.string().nullable().optional(),
-    metabolicActivation: z.string().nullable().optional(),
-    species: z.string().nullable().optional(),
-    overallResult: z.string().nullable().optional(),
-    year: z.unknown().optional(),
-})
-    .transform((r) => ({
-    source: r.source ?? "",
-    assayCategory: r.assayCategory ?? "",
-    assayType: r.assayType ?? "",
-    metabolicActivation: r.metabolicActivation ?? "",
-    species: r.species ?? "",
-    overallResult: r.overallResult ?? "",
-    year: toNumberOrNull(r.year),
-}));
-const CancerSchema = z
-    .object({
-    source: z.string().nullable().optional(),
-    classification: z.string().nullable().optional(),
-    cancerClassification: z.string().nullable().optional(),
-    url: z.string().nullable().optional(),
-})
-    .transform((r) => ({
-    source: r.source ?? "",
-    classification: r.classification ?? r.cancerClassification ?? "",
-    url: r.url ?? "",
-}));
-// The chemical-search endpoint returns rows the code reads `dtxsid` from
-// unguarded, so `dtxsid` stays required — a row missing it is a contract break
-// surfaced as `invalid_response`, not a silent `undefined`.
-const CtxChemicalSearchRowSchema = z.object({
-    dtxsid: z.string(),
-    preferredName: z.string().nullable().optional(),
-});
-export function createSearchCtxHazardTool(deps) {
-    return defineTool({
-        id: "search_ctx_hazard",
-        description: "Search EPA CTX Hazard APIs (ToxValDB, ToxRefDB) for toxicological hazard data on a chemical. " +
-            "Returns in-vivo toxicity values (NOAELs, LOAELs, LD50s, BMDs), " +
-            "genetox summaries, and cancer classifications. " +
-            "Use to assess toxicological hazard profile for safety evaluation. " +
-            "Requires EPA_CCTE_API_KEY environment variable.",
-        inputSchema: z.object({
-            query: z.string().describe("Chemical identifier: DTXSID (e.g. DTXSID7020182), CASRN (e.g. 80-05-7), " + "or chemical name (e.g. bisphenol A)"),
-            dataType: z
-                .enum(["toxval", "genetox", "cancer", "all"])
-                .default("all")
-                .describe("'toxval' for ToxValDB dose-response data (NOAELs, LOAELs, LD50s), " +
-                "'genetox' for genotoxicity summaries, " +
-                "'cancer' for cancer classifications, " +
-                "'all' for combined results"),
-            limit: z.number().int().min(1).max(100).default(30).describe("Max results per category"),
-        }),
-        execute: async ({ query, dataType = "all", limit = 30 }) => {
-            const headers = getEpaCcteHeaders(deps.apiKey);
-            const resolved = await resolveDtxsid(query, headers);
-            // "No chemical found" is an expected outcome — a data variant, not an error.
-            if (!resolved)
-                return ok({ found: false, query });
-            const { dtxsid, preferredName } = resolved;
-            const result = {
-                found: true,
-                dtxsid,
-                preferredName,
-            };
-            const fetchers = [];
-            if (dataType === "toxval" || dataType === "all") {
-                fetchers.push(fetchToxval(dtxsid, headers, limit).then((v) => {
-                    result.toxval = v;
-                }));
-            }
-            if (dataType === "genetox" || dataType === "all") {
-                fetchers.push(fetchGenetox(dtxsid, headers, limit).then((v) => {
-                    result.genetox = v;
-                }));
-            }
-            if (dataType === "cancer" || dataType === "all") {
-                fetchers.push(fetchCancer(dtxsid, headers).then((v) => {
-                    result.cancer = v;
-                }));
-            }
-            await Promise.all(fetchers);
-            return ok(result);
-        },
-    });
-}
-async function resolveDtxsid(query, headers) {
-    if (query.startsWith("DTXSID")) {
-        return { dtxsid: query, preferredName: query };
-    }
-    const url = `${EPA_CCTE_BASE}/chemical/search/equal/${encodeURIComponent(query)}`;
-    const res = await apiFetchValidated(url, z.array(CtxChemicalSearchRowSchema), { headers });
-    if (res.isErr())
-        throw new Error(describeApiError(res.error));
-    if (!res.value?.length)
-        return null;
-    const chem = res.value[0];
-    return {
-        dtxsid: chem.dtxsid,
-        preferredName: chem.preferredName ?? query,
-    };
-}
-async function fetchToxval(dtxsid, headers, limit) {
-    const url = `${EPA_CCTE_BASE}/hazard/toxval/search/by-dtxsid/${dtxsid}`;
-    const res = await apiFetchValidated(url, z.array(ToxValSchema), { headers });
-    if (res.isErr() || !Array.isArray(res.value))
-        return [];
-    return res.value.slice(0, limit);
-}
-function toNumberOrNull(v) {
-    if (v == null || v === "")
-        return null;
-    const n = typeof v === "number" ? v : Number(v);
-    return Number.isFinite(n) ? n : null;
-}
-async function fetchGenetox(dtxsid, headers, limit) {
-    const url = `${EPA_CCTE_BASE}/hazard/genetox/summary/search/by-dtxsid/${dtxsid}`;
-    const res = await apiFetchValidated(url, z.array(GenetoxSchema), { headers });
-    if (res.isErr() || !Array.isArray(res.value))
-        return [];
-    return res.value.slice(0, limit);
-}
-async function fetchCancer(dtxsid, headers) {
-    const url = `${EPA_CCTE_BASE}/hazard/cancer-summary/search/by-dtxsid/${dtxsid}`;
-    const res = await apiFetchValidated(url, z.array(CancerSchema), { headers });
-    if (res.isErr() || !Array.isArray(res.value))
-        return [];
-    return res.value;
-}

package/dist/tools/bio/search-opentargets.d.ts

@@ -1,11 +0,0 @@
-/**
- * searchOpenTargets — query Open Targets Platform for target-disease
- * associations, genetic evidence, tractability, and known drug scores.
- */
-export declare const searchOpenTargetsTool: import("../define-tool.js").Tool<{
-    query: string;
-    searchType: "target" | "disease";
-    limit: number;
-}, {
-    associations: import("../lib/opentargets-client.js").Association[];
-}>;

package/dist/tools/bio/search-opentargets.js

@@ -1,25 +0,0 @@
-/**
- * searchOpenTargets — query Open Targets Platform for target-disease
- * associations, genetic evidence, tractability, and known drug scores.
- */
-import { ok } from "neverthrow";
-import { z } from "zod";
-import { defineTool } from "../define-tool.js";
-import { searchDiseaseAssociations, searchTargetAssociations } from "../lib/opentargets-client.js";
-export const searchOpenTargetsTool = defineTool({
-    id: "search_opentargets",
-    description: "Search Open Targets Platform for target-disease associations, genetic evidence, tractability, and known drug scores. Query by Ensembl gene ID (target mode) or EFO disease ID (disease mode).",
-    inputSchema: z.object({
-        query: z.string().describe("Ensembl gene ID (e.g. ENSG00000141510) or EFO disease ID (e.g. EFO_0000311)"),
-        searchType: z.enum(["target", "disease"]).describe("'target' to find diseases for a gene, 'disease' to find targets for a disease"),
-        limit: z.number().int().min(1).max(100).default(25).describe("Max results to return"),
-    }),
-    execute: async ({ query, searchType, limit = 25 }) => {
-        if (searchType === "target") {
-            const targetInfo = await searchTargetAssociations(query, limit);
-            return ok({ targetInfo, associations: targetInfo?.associations ?? [] });
-        }
-        const associations = await searchDiseaseAssociations(query, limit);
-        return ok({ associations });
-    },
-});

package/dist/tools/bio/search-pubchem-compound.d.ts

@@ -1,26 +0,0 @@
-/**
- * searchPubchemCompound tool — resolve compounds against PubChem's 110M+ database.
- *
- * Supports search by name, SMILES, InChI, InChIKey, or CID.
- * Returns compound identity and computed molecular properties.
- */
-export declare const searchPubchemCompoundTool: import("../define-tool.js").Tool<{
-    query: string;
-    searchBy: "name" | "smiles" | "inchikey" | "cid" | "inchi";
-}, {
-    results: {
-        cid: number;
-        canonicalSmiles: string | null;
-        molecularFormula: string | null;
-        molecularWeight: number | null;
-        iupacName: string | null;
-        inchi: string | null;
-        inchiKey: string | null;
-        xlogp: number | null;
-        tpsa: number | null;
-        hbondDonorCount: number | null;
-        hbondAcceptorCount: number | null;
-        rotatableBondCount: number | null;
-        complexity: number | null;
-    }[];
-}>;

package/dist/tools/bio/search-pubchem-compound.js

@@ -1,110 +0,0 @@
-/**
- * searchPubchemCompound tool — resolve compounds against PubChem's 110M+ database.
- *
- * Supports search by name, SMILES, InChI, InChIKey, or CID.
- * Returns compound identity and computed molecular properties.
- */
-import { ok } from "neverthrow";
-import { z } from "zod";
-import { defineTool } from "../define-tool.js";
-import { apiFetchValidated, describeApiError } from "../lib/api-utils.js";
-import { PUBCHEM_HEADERS as HEADERS, PUBCHEM_BASE } from "../lib/pubchem-config.js";
-const PROPERTY_LIST = [
-    "MolecularFormula",
-    "MolecularWeight",
-    "CanonicalSMILES",
-    "InChI",
-    "InChIKey",
-    "IUPACName",
-    "XLogP",
-    "TPSA",
-    "HBondDonorCount",
-    "HBondAcceptorCount",
-    "RotatableBondCount",
-    "Complexity",
-].join(",");
-// A single schema that both validates and normalizes one PUG-REST property row:
-// the `.object(...)` half is the wire shape (every field optional — PubChem
-// omits absent properties), the `.transform(...)` half maps it to the camelCase
-// `Compound` we return. Parsing IS the validation, and because the transform
-// rides on the schema, `z.infer` below is the OUTPUT type — no separate raw
-// interface or mapper.
-const PugPropertyRowSchema = z
-    .object({
-    CID: z.number().optional(),
-    CanonicalSMILES: z.string().optional(),
-    MolecularFormula: z.string().optional(),
-    // PUG-REST serializes MolecularWeight as a string (e.g. "180.16") to
-    // preserve significant figures; accept both and let the transform's
-    // `Number(...)` normalize it.
-    MolecularWeight: z.union([z.number(), z.string()]).optional(),
-    IUPACName: z.string().optional(),
-    InChI: z.string().optional(),
-    InChIKey: z.string().optional(),
-    XLogP: z.number().optional(),
-    TPSA: z.number().optional(),
-    HBondDonorCount: z.number().optional(),
-    HBondAcceptorCount: z.number().optional(),
-    RotatableBondCount: z.number().optional(),
-    Complexity: z.number().optional(),
-})
-    .transform((raw) => ({
-    cid: raw.CID ?? 0,
-    canonicalSmiles: raw.CanonicalSMILES ?? null,
-    molecularFormula: raw.MolecularFormula ?? null,
-    molecularWeight: raw.MolecularWeight != null ? Number(raw.MolecularWeight) : null,
-    iupacName: raw.IUPACName ?? null,
-    inchi: raw.InChI ?? null,
-    inchiKey: raw.InChIKey ?? null,
-    xlogp: raw.XLogP ?? null,
-    tpsa: raw.TPSA ?? null,
-    hbondDonorCount: raw.HBondDonorCount ?? null,
-    hbondAcceptorCount: raw.HBondAcceptorCount ?? null,
-    rotatableBondCount: raw.RotatableBondCount ?? null,
-    complexity: raw.Complexity ?? null,
-}));
-const PubChemPropertyResponseSchema = z.object({
-    PropertyTable: z.object({ Properties: z.array(PugPropertyRowSchema).optional() }).optional(),
-});
-/** Build the PUG-REST URL path segment for the given search type. */
-function buildNamespace(searchBy, query) {
-    switch (searchBy) {
-        case "name":
-            return `compound/name/${encodeURIComponent(query)}`;
-        case "smiles":
-            return `compound/smiles/${encodeURIComponent(query)}`;
-        case "inchi":
-            return `compound/inchi/${encodeURIComponent(query)}`;
-        case "inchikey":
-            return `compound/inchikey/${encodeURIComponent(query)}`;
-        case "cid":
-            return `compound/cid/${encodeURIComponent(query)}`;
-        default:
-            return `compound/name/${encodeURIComponent(query)}`;
-    }
-}
-export const searchPubchemCompoundTool = defineTool({
-    id: "search_pubchem_compound",
-    description: "Search PubChem for a compound by name, SMILES, InChI, InChIKey, or CID. " +
-        "Returns compound identity (CID, SMILES, InChI, IUPAC name) and computed properties " +
-        "(molecular weight, XLogP, TPSA, HBD, HBA, rotatable bonds, complexity). " +
-        "PubChem covers 110M+ compounds — use when ChEMBL doesn't find the compound.",
-    inputSchema: z.object({
-        query: z.string().min(1).describe("Search term: compound name, SMILES, InChI, InChIKey, or CID"),
-        searchBy: z.enum(["name", "smiles", "inchi", "inchikey", "cid"]).describe("Identifier type for the query"),
-    }),
-    execute: async ({ query, searchBy }) => {
-        const namespace = buildNamespace(searchBy, query);
-        const url = `${PUBCHEM_BASE}/${namespace}/property/${PROPERTY_LIST}/JSON`;
-        const res = await apiFetchValidated(url, PubChemPropertyResponseSchema, { headers: HEADERS });
-        if (res.isErr()) {
-            // PubChem returns 404 when the query matches no compound — expected.
-            if (res.error.type === "http_status" && res.error.status === 404)
-                return ok({ results: [] });
-            throw new Error(describeApiError(res.error));
-        }
-        // Already validated + normalized by PugPropertyRowSchema's transform.
-        const rows = res.value.PropertyTable?.Properties ?? [];
-        return ok({ results: rows });
-    },
-});

package/dist/tools/bio/search-pubmed.d.ts

@@ -1,17 +0,0 @@
-/**
- * searchPubMed — search PubMed via NCBI E-utilities.
- */
-export declare function createSearchPubMedTool(deps: {
-    ncbiApiKey?: string;
-}): import("../define-tool.js").Tool<{
-    query: string;
-    maxResults: number;
-    sort: "date" | "relevance";
-    dateRange?: {
-        from: string;
-        to: string;
-    } | undefined;
-}, {
-    totalFound: number;
-    results: import("../lib/ncbi-utils.js").PubMedSummary[];
-}>;

package/dist/tools/bio/search-pubmed.js

@@ -1,31 +0,0 @@
-/**
- * searchPubMed — search PubMed via NCBI E-utilities.
- */
-import { ok } from "neverthrow";
-import { z } from "zod";
-import { defineTool } from "../define-tool.js";
-import { searchPubmed } from "../lib/pubmed-client.js";
-export function createSearchPubMedTool(deps) {
-    return defineTool({
-        id: "search_pubmed",
-        description: "Search PubMed for scientific articles using NCBI E-utilities. " +
-            "The query uses PubMed search syntax — use MeSH terms (e.g., " +
-            '"breast neoplasms"[MeSH]), field tags ([Title/Abstract], [Author], [Gene]), ' +
-            "and Boolean operators (AND, OR, NOT). " +
-            'Example: "BRCA1"[Gene] AND "breast neoplasms"[MeSH] AND "drug resistance"[Title/Abstract]. ' +
-            "Returns PMIDs, titles, journal names, publication years, and author summaries.",
-        inputSchema: z.object({
-            query: z.string().describe("PubMed search query. Supports MeSH terms, field tags, and Boolean operators."),
-            maxResults: z.number().int().min(1).max(50).default(10).describe("Maximum number of results to return (1–50, default 10)"),
-            sort: z.enum(["relevance", "date"]).default("relevance").describe('Sort order: "relevance" or "date" (default "relevance")'),
-            dateRange: z
-                .object({
-                from: z.string().describe("Start date in YYYY/MM/DD format"),
-                to: z.string().describe("End date in YYYY/MM/DD format"),
-            })
-                .optional()
-                .describe("Optional date range filter"),
-        }),
-        execute: async ({ query, maxResults, sort, dateRange }) => ok(await searchPubmed(deps.ncbiApiKey, query, { maxResults, sort, dateRange })),
-    });
-}

package/dist/tools/bio/search-targets.d.ts

@@ -1,9 +0,0 @@
-/**
- * searchTargets tool — search ChEMBL for biological targets.
- */
-export declare const searchTargetsTool: import("../define-tool.js").Tool<{
-    query: string;
-    limit: number;
-}, {
-    targets: import("../lib/chembl-client.js").ChemblTarget[];
-}>;

package/dist/tools/bio/search-targets.js

@@ -1,20 +0,0 @@
-/**
- * searchTargets tool — search ChEMBL for biological targets.
- */
-import { ok } from "neverthrow";
-import { z } from "zod";
-import { defineTool } from "../define-tool.js";
-import { searchTargets } from "../lib/chembl-client.js";
-export const searchTargetsTool = defineTool({
-    id: "search_targets",
-    description: "Search ChEMBL for biological targets by gene symbol, protein name, or ChEMBL ID. " +
-        "Returns target metadata including ChEMBL IDs, target type, organism, and gene names.",
-    inputSchema: z.object({
-        query: z.string().min(1).describe("Search term: gene symbol (e.g. 'EGFR'), protein name, or ChEMBL target ID"),
-        limit: z.number().int().min(1).max(25).default(25).describe("Maximum number of targets to return"),
-    }),
-    execute: async ({ query, limit }) => {
-        const targets = await searchTargets(query, limit);
-        return ok({ targets });
-    },
-});

package/dist/tools/bio/search-toxcast.d.ts

@@ -1,36 +0,0 @@
-/**
- * searchToxcast — search EPA ToxCast/Tox21 high-throughput screening data
- * for a chemical via the CTX Bioactivity API.
- */
-interface ToxcastAssayResult {
-    aeid: number;
-    assayEndpoint: string;
-    ac50: number | null;
-    hitCall: number;
-    maxMean: number | null;
-    model: string;
-    flags: string[];
-}
-type ToxcastOutput = {
-    found: false;
-    query: string;
-} | {
-    found: true;
-    chemical: {
-        dtxsid: string;
-        preferredName: string;
-        casrn: string | null;
-        totalAssays: number;
-        activeAssays: number;
-        activeHitRate: number;
-        results: ToxcastAssayResult[];
-    };
-};
-export declare function createSearchToxcastTool(deps: {
-    apiKey: string;
-}): import("../define-tool.js").Tool<{
-    query: string;
-    activeOnly: boolean;
-    limit: number;
-}, ToxcastOutput>;
-export {};

package/dist/tools/bio/search-toxcast.js

@@ -1,141 +0,0 @@
-/**
- * searchToxcast — search EPA ToxCast/Tox21 high-throughput screening data
- * for a chemical via the CTX Bioactivity API.
- */
-import { ok } from "neverthrow";
-import { z } from "zod";
-import { defineTool } from "../define-tool.js";
-import { apiFetchValidated, describeApiError } from "../lib/api-utils.js";
-import { EPA_CCTE_BASE, getEpaCcteHeaders } from "../lib/toxcast-config.js";
-// Raw CTX Bioactivity API wire shapes, validated at the fetch boundary. Fields
-// are optional because the API omits absent values; `dtxsid` stays required
-// because `resolveDtxsid` reads it without a guard, so a row missing it is a
-// contract break surfaced as `invalid_response` rather than a runtime error.
-// The row-shaping/filtering logic in `execute` stays put — it depends on the
-// resolved chemical, the assay-name map, and the `activeOnly`/`limit` inputs.
-const CtxChemicalSearchRowSchema = z.object({
-    dtxsid: z.string(),
-    preferredName: z.string().optional(),
-    casrn: z.string().nullable().optional(),
-});
-const ToxcastMc5ParamSchema = z.object({
-    ac50: z.number().optional(),
-    acc: z.number().optional(),
-});
-const ToxcastMc6ParamSchema = z.object({
-    flag: z.unknown().optional(),
-});
-const ToxcastBioactivityRowSchema = z.object({
-    aeid: z.number().optional(),
-    hitc: z.number().optional(),
-    maxMean: z.number().nullable().optional(),
-    modl: z.string().optional(),
-    mc5Param: ToxcastMc5ParamSchema.nullable().optional(),
-    mc6Param: ToxcastMc6ParamSchema.nullable().optional(),
-});
-const ToxcastAssaySummaryRowSchema = z.object({
-    aeid: z.number().optional(),
-    aenm: z.string().optional(),
-});
-export function createSearchToxcastTool(deps) {
-    return defineTool({
-        id: "search_toxcast",
-        description: "Search EPA ToxCast/Tox21 high-throughput screening data for a chemical via the CTX Bioactivity API. " +
-            "Returns in-vitro bioactivity results across hundreds of assay endpoints " +
-            "(nuclear receptors, stress response, mitochondrial toxicity, etc.). " +
-            "Use to assess toxicological liability of compounds or drug targets. " +
-            "Requires EPA_CCTE_API_KEY environment variable.",
-        inputSchema: z.object({
-            query: z.string().describe("Chemical identifier: DTXSID (e.g. DTXSID7020182), CASRN (e.g. 80-05-7), " + "or chemical name (e.g. bisphenol A)"),
-            activeOnly: z.boolean().default(true).describe("Return only active (hit) assays. Set false for all tested assays."),
-            limit: z.number().int().min(1).max(200).default(50).describe("Max assay results to return (sorted by AC50 ascending for actives)"),
-        }),
-        execute: async ({ query, activeOnly = true, limit = 50 }) => {
-            const headers = getEpaCcteHeaders(deps.apiKey);
-            const resolved = await resolveDtxsid(query, headers);
-            // "No chemical found" is an expected outcome — a data variant, not an error.
-            if (!resolved)
-                return ok({ found: false, query });
-            const { dtxsid, preferredName, casrn } = resolved;
-            const aeidMap = await fetchAssayNames(dtxsid, headers);
-            const bioUrl = `${EPA_CCTE_BASE}/bioactivity/data/search/by-dtxsid/${dtxsid}`;
-            const bioRes = await apiFetchValidated(bioUrl, z.array(ToxcastBioactivityRowSchema), { headers });
-            if (bioRes.isErr())
-                throw new Error(describeApiError(bioRes.error));
-            const allResults = bioRes.value ?? [];
-            const totalAssays = allResults.length;
-            const activeAssays = allResults.filter((r) => r.hitc === 1).length;
-            const filtered = activeOnly ? allResults.filter((r) => r.hitc === 1) : allResults;
-            filtered.sort((a, b) => extractAc50(a) - extractAc50(b));
-            const results = filtered.slice(0, limit).map((r) => {
-                const aeid = r.aeid ?? 0;
-                const mc6 = r.mc6Param ?? {};
-                const flags = Array.isArray(mc6.flag) ? mc6.flag : [];
-                return {
-                    aeid,
-                    assayEndpoint: aeidMap.get(aeid) ?? `aeid:${aeid}`,
-                    ac50: extractAc50Raw(r),
-                    hitCall: r.hitc ?? 0,
-                    maxMean: r.maxMean ?? null,
-                    model: r.modl ?? "",
-                    flags,
-                };
-            });
-            return ok({
-                found: true,
-                chemical: {
-                    dtxsid,
-                    preferredName,
-                    casrn,
-                    totalAssays,
-                    activeAssays,
-                    activeHitRate: totalAssays > 0 ? Math.round((activeAssays / totalAssays) * 1000) / 1000 : 0,
-                    results,
-                },
-            });
-        },
-    });
-}
-function extractAc50(r) {
-    return extractAc50Raw(r) ?? Infinity;
-}
-function extractAc50Raw(r) {
-    const mc5 = r.mc5Param;
-    if (mc5 && typeof mc5 === "object") {
-        if (typeof mc5.ac50 === "number")
-            return mc5.ac50;
-        if (typeof mc5.acc === "number")
-            return mc5.acc;
-    }
-    return null;
-}
-async function resolveDtxsid(query, headers) {
-    if (query.startsWith("DTXSID")) {
-        return { dtxsid: query, preferredName: query, casrn: null };
-    }
-    const searchUrl = `${EPA_CCTE_BASE}/chemical/search/equal/${encodeURIComponent(query)}`;
-    const searchRes = await apiFetchValidated(searchUrl, z.array(CtxChemicalSearchRowSchema), { headers });
-    if (searchRes.isErr())
-        throw new Error(describeApiError(searchRes.error));
-    if (!searchRes.value?.length)
-        return null;
-    const chem = searchRes.value[0];
-    return {
-        dtxsid: chem.dtxsid,
-        preferredName: chem.preferredName ?? query,
-        casrn: chem.casrn ?? null,
-    };
-}
-async function fetchAssayNames(dtxsid, headers) {
-    const map = new Map();
-    const url = `${EPA_CCTE_BASE}/bioactivity/data/summary/search/by-dtxsid/${dtxsid}`;
-    const res = await apiFetchValidated(url, z.array(ToxcastAssaySummaryRowSchema), { headers });
-    if (res.isOk() && Array.isArray(res.value)) {
-        for (const s of res.value) {
-            if (s.aeid != null && s.aenm) {
-                map.set(s.aeid, s.aenm);
-            }
-        }
-    }
-    return map;
-}

package/dist/workflows/register-workflows.d.ts

@@ -1,51 +0,0 @@
-/**
- * Single registration call site for the analysis-side DBOS workflows.
- *
- * This module is the **one place** that calls `registerExecuteAnalysis` and
- * `registerSandboxStep`, binding the parent + child workflow bodies to the
- * running DBOS engine. Keeping both registrations in one file holds a single
- * invariant: both workflows land under the same `applicationVersion` stamp
- * that `launchDbos` writes onto the engine (`harness/runtime/dbos.ts`).
- * Blue/green drains gate on `dbos.application_versions`, so registering the
- * parent and child together under one stamp guarantees a drain treats them
- * as one cohort.
- *
- * Deps are supplied by the composition root: `registerAnalysisWorkflows`
- * takes a fully-formed deps bundle and passes each half straight through to
- * the per-workflow register functions. This module constructs nothing —
- * it only wires.
- */
-import { type ExecuteAnalysisDeps, type ExecuteAnalysisInput, type ExecuteAnalysisResult } from "./execute-analysis.js";
-import { type SandboxStepDeps, type SandboxStepInput, type SandboxStepResult } from "./sandbox-step.js";
-export interface AnalysisWorkflowDeps {
-    readonly executeAnalysis: ExecuteAnalysisDeps;
-    readonly sandboxStep: SandboxStepDeps;
-}
-export interface RegisteredAnalysisWorkflows {
-    readonly executeAnalysis: (input: ExecuteAnalysisInput) => Promise<ExecuteAnalysisResult>;
-    readonly sandboxStep: (input: SandboxStepInput) => Promise<SandboxStepResult>;
-}
-/**
- * Register the parent + child workflows with the running DBOS engine.
- *
- * Call this BEFORE `launchDbos`: `DBOS.launch()` runs recovery synchronously and
- * resolves in-flight workflows by their registered name, so a workflow that is
- * not registered at launch cannot be reclaimed. `runtime/assemble.ts` — the
- * declared source of truth for wiring order — registers every workflow before
- * launch for exactly this reason, and the embedded runtime does the same.
- * Idempotency is owned by the SDK — calling twice with the same name is a
- * `DBOS.registerWorkflow` invariant violation, not something this module
- * guards against.
- *
- * Scope: this helper takes a fully-formed `AnalysisWorkflowDeps`, so it fits
- * only a caller that already holds a registered sandbox-step callable —
- * `ExecuteAnalysisDeps.sandboxStepCallable` (inside `deps.executeAnalysis`)
- * exists only after `registerSandboxStep` has run. A caller that still needs
- * that child callable must instead register the two workflows directly in
- * assemble-order — register the child first, then feed its callable into the
- * parent's deps — the way `runtime/assemble.ts` does; registering the child
- * here as well would make its `registerSandboxStep` a second registration under
- * the same name, which the SDK rejects. No in-tree caller holds a
- * pre-registered child callable, so this helper is currently uncalled.
- */
-export declare function registerAnalysisWorkflows(deps: AnalysisWorkflowDeps): RegisteredAnalysisWorkflows;