@inflexa-ai/harness 0.1.1 → 0.2.0

package/dist/tools/lib/ctx-ops.js

@@ -0,0 +1,450 @@
+/**
+ * EPA CompTox (CTX) operations — the four datasets the CompTox tools expose:
+ * ToxCast/Tox21 bioactivity, hazard (ToxValDB/ToxRefDB), chemical identity +
+ * physicochemical properties, and exposure.
+ *
+ * Every dataset keys off a DTXSID, so `resolveDtxsid` is the single entry
+ * point they share: a DTXSID is used directly, anything else is resolved by
+ * exact match against the chemical-search endpoint. `null` means the query
+ * resolved to no chemical — an expected outcome, not an error.
+ */
+import { z } from "zod";
+import { apiFetchValidated, describeApiError } from "./api-utils.js";
+import { EPA_CCTE_BASE } from "./toxcast-config.js";
+// 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`. The other fields
+// are optional: the API omits absent values.
+const CtxChemicalSearchRowSchema = z.object({
+    dtxsid: z.string(),
+    preferredName: z.string().nullable().optional(),
+    casrn: z.string().nullable().optional(),
+});
+/** Resolve a DTXSID / CASRN / name to a chemical. `null` = no match (valid no-data). */
+export async function resolveDtxsid(query, headers) {
+    if (query.startsWith("DTXSID")) {
+        return { dtxsid: query, preferredName: query, casrn: null };
+    }
+    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,
+        casrn: chem.casrn ?? null,
+    };
+}
+// Raw CTX Bioactivity API wire shapes, validated at the fetch boundary. Fields
+// are optional because the API omits absent values.
+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(),
+});
+/**
+ * ToxCast/Tox21 assay results for a chemical, sorted by AC50 ascending.
+ * `totalAssays` / `activeAssays` / `activeHitRate` always describe the full
+ * tested panel, never the returned slice.
+ */
+export async function fetchToxcastBioactivity(dtxsid, headers, opts) {
+    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 = opts.activeOnly ? allResults.filter((r) => r.hitc === 1) : allResults;
+    filtered.sort((a, b) => extractAc50(a) - extractAc50(b));
+    const results = filtered.slice(0, opts.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 {
+        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 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;
+}
+/* ---------------------------------- hazard ---------------------------------- */
+// 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 ?? "",
+}));
+/**
+ * In-vivo hazard data for a chemical. `limit` caps toxval and genetox only —
+ * cancer classifications always come back whole.
+ */
+export async function fetchCtxHazardData(dtxsid, headers, opts) {
+    const { dataType, limit } = opts;
+    const data = {};
+    const fetchers = [];
+    if (dataType === "toxval" || dataType === "all") {
+        fetchers.push(fetchToxval(dtxsid, headers, limit).then((v) => {
+            data.toxval = v;
+        }));
+    }
+    if (dataType === "genetox" || dataType === "all") {
+        fetchers.push(fetchGenetox(dtxsid, headers, limit).then((v) => {
+            data.genetox = v;
+        }));
+    }
+    if (dataType === "cancer" || dataType === "all") {
+        fetchers.push(fetchCancer(dtxsid, headers).then((v) => {
+            data.cancer = v;
+        }));
+    }
+    await Promise.all(fetchers);
+    return data;
+}
+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;
+}
+// Raw CTX chemical-detail wire shape, validated at the fetch boundary. Every
+// field is optional (the API omits absent values); the mapper below normalizes
+// it into `ChemicalDetail`, folding in the resolved `dtxsid` fallback.
+const RawChemicalDetailSchema = z.object({
+    dtxsid: z.string().optional(),
+    dtxcid: z.string().nullable().optional(),
+    casrn: z.string().nullable().optional(),
+    preferredName: z.string().nullable().optional(),
+    iupacName: z.string().nullable().optional(),
+    molFormula: z.string().nullable().optional(),
+    smiles: z.string().nullable().optional(),
+    inchikey: z.string().nullable().optional(),
+    monoisotopicMass: z.number().nullable().optional(),
+    averageMass: z.number().nullable().optional(),
+    qcLevel: z.number().nullable().optional(),
+    totalAssays: z.number().nullable().optional(),
+    activeAssays: z.number().nullable().optional(),
+    percentAssays: z.number().nullable().optional(),
+    pubchemCid: z.number().nullable().optional(),
+    pubmedCount: z.number().nullable().optional(),
+    sourcesCount: z.number().nullable().optional(),
+});
+const RawPropertySummarySchema = z.object({
+    propName: z.string().nullable().optional(),
+    unit: z.string().nullable().optional(),
+    experimentalCount: z.number().nullable().optional(),
+    experimentalMedian: z.number().nullable().optional(),
+    experimentalMin: z.number().nullable().optional(),
+    experimentalMax: z.number().nullable().optional(),
+    predictedCount: z.number().nullable().optional(),
+    predictedMedian: z.number().nullable().optional(),
+    predictedMin: z.number().nullable().optional(),
+    predictedMax: z.number().nullable().optional(),
+});
+/** Chemical identity, mass, and dashboard counts for a DTXSID. */
+export async function fetchCtxChemicalDetail(dtxsid, headers) {
+    const detailUrl = `${EPA_CCTE_BASE}/chemical/detail/search/by-dtxsid/${dtxsid}?projection=chemicaldetailstandard`;
+    const detailRes = await apiFetchValidated(detailUrl, RawChemicalDetailSchema, { headers });
+    if (detailRes.isErr())
+        throw new Error(describeApiError(detailRes.error));
+    const d = detailRes.value ?? {};
+    return {
+        dtxsid: d.dtxsid ?? dtxsid,
+        dtxcid: d.dtxcid ?? "",
+        casrn: d.casrn ?? null,
+        preferredName: d.preferredName ?? "",
+        iupacName: d.iupacName ?? "",
+        molFormula: d.molFormula ?? "",
+        smiles: d.smiles ?? "",
+        inchikey: d.inchikey ?? "",
+        monoisotopicMass: d.monoisotopicMass ?? null,
+        averageMass: d.averageMass ?? null,
+        qcLevel: d.qcLevel ?? null,
+        totalAssays: d.totalAssays ?? null,
+        activeAssays: d.activeAssays ?? null,
+        percentAssays: d.percentAssays ?? null,
+        pubchemCid: d.pubchemCid ?? null,
+        pubmedCount: d.pubmedCount ?? null,
+        sourcesCount: d.sourcesCount ?? null,
+    };
+}
+/** Experimental + predicted physicochemical property summaries. `undefined` = none served. */
+export async function fetchCtxChemicalProperties(dtxsid, headers) {
+    const propUrl = `${EPA_CCTE_BASE}/chemical/property/summary/search/by-dtxsid/${dtxsid}`;
+    const propRes = await apiFetchValidated(propUrl, z.array(RawPropertySummarySchema), { headers });
+    if (propRes.isOk() && Array.isArray(propRes.value)) {
+        return propRes.value.map((p) => ({
+            propName: p.propName ?? "",
+            unit: p.unit ?? "",
+            experimentalCount: p.experimentalCount ?? null,
+            experimentalMedian: p.experimentalMedian ?? null,
+            experimentalMin: p.experimentalMin ?? null,
+            experimentalMax: p.experimentalMax ?? null,
+            predictedCount: p.predictedCount ?? null,
+            predictedMedian: p.predictedMedian ?? null,
+            predictedMin: p.predictedMin ?? null,
+            predictedMax: p.predictedMax ?? null,
+        }));
+    }
+    return undefined;
+}
+// SEEM exposure-prediction wire shape (endpoint returns a single object or an
+// array). `probabilityPesticde` is the API's own misspelling, read as a
+// fallback before the corrected `probabilityPesticide`, so both stay modeled.
+const RawSeemPredictionSchema = z.object({
+    dtxsid: z.string().optional(),
+    productionVolume: z.number().nullable().optional(),
+    units: z.string().nullable().optional(),
+    probabilityDietary: z.number().nullable().optional(),
+    probabilityResidential: z.number().nullable().optional(),
+    probabilityPesticde: z.number().nullable().optional(),
+    probabilityPesticide: z.number().nullable().optional(),
+    probabilityIndustrial: z.number().nullable().optional(),
+});
+const RawHttkRowSchema = z.object({
+    parameter: z.string().nullable().optional(),
+    measured: z.number().nullable().optional(),
+    predicted: z.number().nullable().optional(),
+    units: z.string().nullable().optional(),
+    model: z.string().nullable().optional(),
+    species: z.string().nullable().optional(),
+    reference: z.string().nullable().optional(),
+});
+const RawFunctionalUseRowSchema = z.object({
+    functioncategory: z.string().nullable().optional(),
+    reportedfunction: z.string().nullable().optional(),
+    doctitle: z.string().nullable().optional(),
+});
+const RawProductDataRowSchema = z.object({
+    productname: z.string().nullable().optional(),
+    gencat: z.string().nullable().optional(),
+    prodfam: z.string().nullable().optional(),
+    prodtype: z.string().nullable().optional(),
+    centralweightfraction: z.number().nullable().optional(),
+    weightfractiontype: z.string().nullable().optional(),
+});
+/**
+ * Human-exposure data for a chemical. `limit` caps functional-use and
+ * product-data only — seem and httk always come back whole.
+ */
+export async function fetchCtxExposureData(dtxsid, headers, opts) {
+    const { dataType, limit } = opts;
+    const data = {};
+    const fetchers = [];
+    if (dataType === "seem" || dataType === "all") {
+        fetchers.push(fetchSeem(dtxsid, headers).then((v) => {
+            data.seem = v;
+        }));
+    }
+    if (dataType === "httk" || dataType === "all") {
+        fetchers.push(fetchHttk(dtxsid, headers).then((v) => {
+            data.httk = v;
+        }));
+    }
+    if (dataType === "functional-use" || dataType === "all") {
+        fetchers.push(fetchFunctionalUse(dtxsid, headers, limit).then((v) => {
+            data.functionalUse = v;
+        }));
+    }
+    if (dataType === "product-data" || dataType === "all") {
+        fetchers.push(fetchProductData(dtxsid, headers, limit).then((v) => {
+            data.productData = v;
+        }));
+    }
+    await Promise.all(fetchers);
+    return data;
+}
+async function fetchSeem(dtxsid, headers) {
+    const url = `${EPA_CCTE_BASE}/exposure/seem/general/search/by-dtxsid/${dtxsid}`;
+    const res = await apiFetchValidated(url, z.union([RawSeemPredictionSchema, z.array(RawSeemPredictionSchema)]), { headers });
+    if (res.isErr() || !res.value)
+        return undefined;
+    const d = Array.isArray(res.value) ? res.value[0] : res.value;
+    if (!d)
+        return undefined;
+    return {
+        dtxsid: d.dtxsid ?? dtxsid,
+        productionVolume: d.productionVolume ?? null,
+        units: d.units ?? "",
+        probabilityDietary: d.probabilityDietary ?? null,
+        probabilityResidential: d.probabilityResidential ?? null,
+        probabilityPesticide: d.probabilityPesticde ?? d.probabilityPesticide ?? null,
+        probabilityIndustrial: d.probabilityIndustrial ?? null,
+    };
+}
+async function fetchHttk(dtxsid, headers) {
+    const url = `${EPA_CCTE_BASE}/exposure/httk/search/by-dtxsid/${dtxsid}`;
+    const res = await apiFetchValidated(url, z.array(RawHttkRowSchema), { headers });
+    if (res.isErr() || !Array.isArray(res.value))
+        return [];
+    return res.value.map((r) => ({
+        parameter: r.parameter ?? "",
+        measured: r.measured ?? null,
+        predicted: r.predicted ?? null,
+        units: r.units ?? "",
+        model: r.model ?? "",
+        species: r.species ?? "",
+        reference: r.reference ?? "",
+    }));
+}
+async function fetchFunctionalUse(dtxsid, headers, limit) {
+    const url = `${EPA_CCTE_BASE}/exposure/functional-use/search/by-dtxsid/${dtxsid}`;
+    const res = await apiFetchValidated(url, z.array(RawFunctionalUseRowSchema), { headers });
+    if (res.isErr() || !Array.isArray(res.value))
+        return [];
+    return res.value.slice(0, limit).map((r) => ({
+        functionCategory: r.functioncategory ?? "",
+        reportedFunction: r.reportedfunction ?? "",
+        docTitle: r.doctitle ?? "",
+    }));
+}
+async function fetchProductData(dtxsid, headers, limit) {
+    const url = `${EPA_CCTE_BASE}/exposure/product-data/search/by-dtxsid/${dtxsid}`;
+    const res = await apiFetchValidated(url, z.array(RawProductDataRowSchema), { headers });
+    if (res.isErr() || !Array.isArray(res.value))
+        return [];
+    return res.value.slice(0, limit).map((r) => ({
+        productName: r.productname ?? "",
+        generalCategory: r.gencat ?? "",
+        productFamily: r.prodfam ?? "",
+        productType: r.prodtype ?? "",
+        centralWeightFraction: r.centralweightfraction ?? null,
+        weightFractionType: r.weightfractiontype ?? "",
+    }));
+}

package/dist/tools/lib/iuphar-client.js

@@ -28,7 +28,16 @@ const IupharTargetSchema = z.object({
 });
 const UNIPROT_ACCESSION_RE = /^[A-Z][0-9][A-Z0-9]{3}[0-9]$/;
 function stripHtml(name) {
-    return name.replace(/<[^>]+>/g, "");
+    // Strip tags to a fixpoint: a single pass can leave a `<…>` behind when
+    // removing an inner tag lets the surrounding angle brackets form a new one,
+    // so repeat until the string stops changing.
+    let out = name;
+    let prev;
+    do {
+        prev = out;
+        out = out.replace(/<[^>]+>/g, "");
+    } while (out !== prev);
+    return out;
 }
 function notFound(error) {
     return error.type === "http_status" && (error.status === 404 || error.status === 204);

package/dist/tools/lib/openfda-client.js

@@ -34,8 +34,16 @@ const OpenFdaLabelSchema = z.object({
     rems_indication: z.unknown().optional(),
     medication_guide: z.unknown().optional(),
 });
+/**
+ * Escape a value for embedding inside a double-quoted openFDA (Lucene) phrase.
+ * The backslash is escaped first so a caller-supplied `\` cannot smuggle an
+ * unescaped `"` past the quote escaping and break out of the phrase.
+ */
+function escapeQueryPhrase(value) {
+    return value.replace(/\\/g, "\\\\").replace(/"/g, '\\"');
+}
 function buildSearch(drugName, serious) {
-    const escaped = drugName.replace(/"/g, '\\"');
+    const escaped = escapeQueryPhrase(drugName);
     let search = `patient.drug.openfda.generic_name:"${escaped}"`;
     if (serious)
         search += "+AND+serious:1";
@@ -68,7 +76,7 @@ export async function getFaersByDrug(drugName, options = {}) {
  * and §2.6.8 risk summary.
  */
 export async function getFaersSeriousness(drugName) {
-    const escaped = drugName.replace(/"/g, '\\"');
+    const escaped = escapeQueryPhrase(drugName);
     const search = `patient.drug.openfda.generic_name:"${escaped}"`;
     const totalUrl = `${OPENFDA_BASE}?search=${encodeURIComponent(search)}&limit=1`;
     const totalRes = await apiFetchValidated(totalUrl, FaersMetaResponseSchema);
@@ -179,7 +187,7 @@ const OpenFdaLabelResponseSchema = z.object({
  */
 export async function getDrugLabelActions(genericName, options = {}) {
     const limit = options.limit ?? 5;
-    const escaped = genericName.replace(/"/g, '\\"');
+    const escaped = escapeQueryPhrase(genericName);
     const search = `openfda.generic_name:"${escaped}"`;
     const url = `${OPENFDA_LABEL_BASE}?search=${encodeURIComponent(search)}` + `&sort=effective_time:desc&limit=${limit}`;
     const res = await apiFetchValidated(url, OpenFdaLabelResponseSchema);

package/dist/tools/lib/pathway-client.js

@@ -8,10 +8,16 @@ import { apiFetch, apiFetchValidated, parseTSV } from "./api-utils.js";
 const KEGG_BASE = "https://rest.kegg.jp";
 const REACTOME_BASE = "https://reactome.org/ContentService";
 export function stripHtmlAndCollapseWs(s) {
-    return s
-        .replace(/<[^>]+>/g, "")
-        .replace(/\s+/g, " ")
-        .trim();
+    // Strip tags to a fixpoint: a single pass can leave a `<…>` behind when
+    // removing an inner tag lets the surrounding angle brackets form a new one,
+    // so repeat until the string stops changing.
+    let out = s;
+    let prev;
+    do {
+        prev = out;
+        out = out.replace(/<[^>]+>/g, "");
+    } while (out !== prev);
+    return out.replace(/\s+/g, " ").trim();
 }
 const ORGANISM_MAP = {
     hsa: "Homo sapiens",

package/dist/tools/lib/pubchem-ops.d.ts

@@ -0,0 +1,74 @@
+/**
+ * PubChem PUG-REST operations — the three lookups the PubChem tools expose.
+ *
+ * One home for the wire schemas, the URL construction, and the "PubChem 404
+ * means no data" contract, so a caller cannot drift from it: every function
+ * returns an empty collection for a 404 and throws on any other API failure.
+ */
+import { z } from "zod";
+export type PubChemSearchBy = "name" | "smiles" | "inchi" | "inchikey" | "cid";
+declare const PugPropertyRowSchema: z.ZodPipe<z.ZodObject<{
+    CID: z.ZodOptional<z.ZodNumber>;
+    CanonicalSMILES: z.ZodOptional<z.ZodString>;
+    MolecularFormula: z.ZodOptional<z.ZodString>;
+    MolecularWeight: z.ZodOptional<z.ZodUnion<readonly [z.ZodNumber, z.ZodString]>>;
+    IUPACName: z.ZodOptional<z.ZodString>;
+    InChI: z.ZodOptional<z.ZodString>;
+    InChIKey: z.ZodOptional<z.ZodString>;
+    XLogP: z.ZodOptional<z.ZodNumber>;
+    TPSA: z.ZodOptional<z.ZodNumber>;
+    HBondDonorCount: z.ZodOptional<z.ZodNumber>;
+    HBondAcceptorCount: z.ZodOptional<z.ZodNumber>;
+    RotatableBondCount: z.ZodOptional<z.ZodNumber>;
+    Complexity: z.ZodOptional<z.ZodNumber>;
+}, z.core.$strip>, z.ZodTransform<{
+    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;
+}, {
+    CID?: number | undefined;
+    CanonicalSMILES?: string | undefined;
+    MolecularFormula?: string | undefined;
+    MolecularWeight?: string | number | undefined;
+    IUPACName?: string | undefined;
+    InChI?: string | undefined;
+    InChIKey?: string | undefined;
+    XLogP?: number | undefined;
+    TPSA?: number | undefined;
+    HBondDonorCount?: number | undefined;
+    HBondAcceptorCount?: number | undefined;
+    RotatableBondCount?: number | undefined;
+    Complexity?: number | undefined;
+}>>;
+export type PubChemCompound = z.infer<typeof PugPropertyRowSchema>;
+export interface PubChemCrossRef {
+    source: string;
+    id: string;
+}
+export interface PubChemAssay {
+    aid: number;
+    assayName: string | null;
+    targetName: string | null;
+    activityOutcome: string | null;
+    activityValue: number | null;
+}
+/** Resolve a compound to its identity + computed properties. Empty array = no match. */
+export declare function fetchPubchemCompounds(query: string, searchBy: PubChemSearchBy): Promise<PubChemCompound[]>;
+/** External registry ids for a CID. Empty array = the CID is in no external registry. */
+export declare function fetchPubchemCrossRefs(cid: number): Promise<PubChemCrossRef[]>;
+/** Bioassay screening summaries for a CID. Empty array = never screened. */
+export declare function fetchPubchemAssays(cid: number, opts: {
+    activeOnly: boolean;
+    limit: number;
+}): Promise<PubChemAssay[]>;
+export {};