@inflexa-ai/harness 0.1.1

package/dist/tools/bio/search-gwas-catalog.d.ts

@@ -0,0 +1,33 @@
+/**
+ * searchGwasCatalog — search NHGRI-EBI GWAS Catalog for SNP-trait associations.
+ *
+ * Public REST API, no key required. Three search modes:
+ *   - 'gene' — gene-trait associations (via SNP-by-gene lookup, then assocs)
+ *   - 'trait' — trait-gene associations (via EFO trait search, then assocs)
+ *   - 'variant' — direct rsID lookup
+ */
+interface GwasAssociation {
+    rsId: string;
+    pValue: number;
+    pValueMantissa: number;
+    pValueExponent: number;
+    riskAllele: string;
+    riskFrequency: string;
+    orBeta: number | null;
+    ci: string;
+    trait: string;
+    mappedGenes: string[];
+    studyAccession: string;
+    pubmedId: string;
+    sampleSize: string;
+}
+export declare const searchGwasCatalogTool: import("../define-tool.js").Tool<{
+    query: string;
+    searchType: "gene" | "trait" | "variant";
+    pValueThreshold: number;
+    limit: number;
+}, {
+    totalFound: number;
+    associations: GwasAssociation[];
+}>;
+export {};

package/dist/tools/bio/search-gwas-catalog.js

@@ -0,0 +1,172 @@
+/**
+ * searchGwasCatalog — search NHGRI-EBI GWAS Catalog for SNP-trait associations.
+ *
+ * Public REST API, no key required. Three search modes:
+ *   - 'gene' — gene-trait associations (via SNP-by-gene lookup, then assocs)
+ *   - 'trait' — trait-gene associations (via EFO trait search, then assocs)
+ *   - 'variant' — direct rsID lookup
+ */
+import { ok } from "neverthrow";
+import { z } from "zod";
+import { defineTool } from "../define-tool.js";
+import { apiFetchValidated, describeApiError } from "../lib/api-utils.js";
+import { GWAS_BASE, GWAS_HEADERS } from "../lib/gwas-catalog-config.js";
+// GWAS Catalog raw wire shapes (HAL+JSON), validated at the fetch boundary.
+// Every field is optional because the API omits absent values; leaf strings
+// that the API can return as an explicit `null` are `.nullable()`.
+const RawGwasStudySchema = z.object({
+    accessionId: z.string().optional(),
+    pubmedId: z.string().optional(),
+    initialSampleSize: z.string().optional(),
+});
+// `_snpRsId` is not on the wire — the 'gene' search path assigns it after
+// parsing (`a._snpRsId = snp.rsId`), so it stays a writable optional field.
+const RawGwasAssociationSchema = z.object({
+    _snpRsId: z.string().optional(),
+    loci: z
+        .array(z.object({
+        strongestRiskAlleles: z.array(z.object({ riskAlleleName: z.string().nullable().optional() })).optional(),
+        authorReportedGenes: z.array(z.object({ geneName: z.string().nullable().optional() })).optional(),
+    }))
+        .optional(),
+    efoTraits: z.array(z.object({ trait: z.string().nullable().optional() })).optional(),
+    study: RawGwasStudySchema.optional(),
+    pvalueMantissa: z.number().optional(),
+    pvalueExponent: z.number().optional(),
+    riskFrequency: z.string().optional(),
+    orPerCopyNum: z.number().nullable().optional(),
+    betaNum: z.number().nullable().optional(),
+    range: z.string().optional(),
+});
+const GwasEmbeddedSchema = z.object({
+    _embedded: z.object({ associations: z.array(RawGwasAssociationSchema).optional() }).optional(),
+    page: z.object({ totalElements: z.number().optional() }).optional(),
+});
+const GwasTraitSearchResponseSchema = z.object({
+    _embedded: z
+        .object({
+        efoTraits: z.array(z.object({ _links: z.object({ self: z.object({ href: z.string().optional() }).optional() }).optional() })).optional(),
+    })
+        .optional(),
+});
+const GwasSnpSearchResponseSchema = z.object({
+    _embedded: z
+        .object({
+        singleNucleotidePolymorphisms: z
+            .array(z.object({
+            rsId: z.string().optional(),
+            _links: z.object({ associations: z.object({ href: z.string().optional() }).optional() }).optional(),
+        }))
+            .optional(),
+    })
+        .optional(),
+});
+function mapAssociation(a) {
+    const loci = a.loci ?? [];
+    const riskAlleles = loci.flatMap((l) => l.strongestRiskAlleles?.map((ra) => String(ra.riskAlleleName ?? "")) ?? []);
+    const genes = loci.flatMap((l) => l.authorReportedGenes?.map((g) => String(g.geneName ?? "")) ?? []);
+    const traits = (a.efoTraits ?? []).map((t) => String(t.trait ?? ""));
+    const study = a.study ?? {};
+    const pMantissa = a.pvalueMantissa ?? 0;
+    const pExponent = a.pvalueExponent ?? 0;
+    return {
+        rsId: String(a._snpRsId ?? riskAlleles[0]?.split("-")[0] ?? ""),
+        pValue: pMantissa * Math.pow(10, pExponent),
+        pValueMantissa: pMantissa,
+        pValueExponent: pExponent,
+        riskAllele: riskAlleles.join(", "),
+        riskFrequency: String(a.riskFrequency ?? ""),
+        orBeta: (a.orPerCopyNum ?? a.betaNum ?? null),
+        ci: String(a.range ?? ""),
+        trait: traits.join("; "),
+        mappedGenes: [...new Set(genes)],
+        studyAccession: String(study.accessionId ?? ""),
+        pubmedId: String(study.pubmedId ?? ""),
+        sampleSize: String(study.initialSampleSize ?? ""),
+    };
+}
+export const searchGwasCatalogTool = defineTool({
+    id: "search_gwas_catalog",
+    description: "Search the NHGRI-EBI GWAS Catalog for genome-wide association study results. " +
+        "Returns SNP associations with traits/diseases, effect sizes, p-values, and mapped genes. " +
+        "Use to find genetic evidence linking genes to phenotypes for target validation or " +
+        "Mendelian randomization support.",
+    inputSchema: z.object({
+        query: z.string().describe("Gene symbol (e.g. PCSK9), trait keyword (e.g. cholesterol), or rsID (e.g. rs11591147)"),
+        searchType: z
+            .enum(["gene", "trait", "variant"])
+            .describe("'gene' for gene-trait associations, 'trait' for trait-gene associations, 'variant' for a specific rsID"),
+        pValueThreshold: z.number().default(5e-8).describe("P-value threshold for genome-wide significance"),
+        limit: z.number().int().min(1).max(100).default(25).describe("Max results to return"),
+    }),
+    execute: async ({ query, searchType, pValueThreshold = 5e-8, limit = 25 }) => {
+        let url;
+        if (searchType === "variant") {
+            const rsId = query.startsWith("rs") ? query : `rs${query}`;
+            url = `${GWAS_BASE}/singleNucleotidePolymorphisms/${rsId}/associations?projection=associationBySnp`;
+        }
+        else if (searchType === "gene") {
+            url = `${GWAS_BASE}/singleNucleotidePolymorphisms/search/findByGene?geneName=${encodeURIComponent(query)}&projection=snpByGene`;
+        }
+        else {
+            url = `${GWAS_BASE}/efoTraits/search/findBySearchQuery?query=${encodeURIComponent(query)}`;
+        }
+        if (searchType === "trait") {
+            const traitRes = await apiFetchValidated(url, GwasTraitSearchResponseSchema, { headers: GWAS_HEADERS });
+            if (traitRes.isErr())
+                throw new Error(describeApiError(traitRes.error));
+            const traits = traitRes.value?._embedded?.efoTraits ?? [];
+            if (traits.length === 0) {
+                return ok({ totalFound: 0, associations: [] });
+            }
+            const traitUri = traits[0]?._links?.self?.href;
+            if (!traitUri) {
+                return ok({ totalFound: 0, associations: [] });
+            }
+            const traitId = traitUri.split("/").pop();
+            url = `${GWAS_BASE}/efoTraits/${traitId}/associations?size=${limit}`;
+        }
+        if (searchType === "gene") {
+            const snpRes = await apiFetchValidated(url, GwasSnpSearchResponseSchema, { headers: GWAS_HEADERS });
+            if (snpRes.isErr())
+                throw new Error(describeApiError(snpRes.error));
+            const snps = snpRes.value?._embedded?.singleNucleotidePolymorphisms ?? [];
+            const allAssocs = [];
+            for (const snp of snps.slice(0, Math.min(limit, 10))) {
+                const assocLink = snp?._links?.associations?.href;
+                if (!assocLink)
+                    continue;
+                const aRes = await apiFetchValidated(assocLink, GwasEmbeddedSchema, {
+                    headers: GWAS_HEADERS,
+                });
+                if (aRes.isOk()) {
+                    for (const a of aRes.value?._embedded?.associations ?? []) {
+                        a._snpRsId = snp.rsId;
+                        allAssocs.push(a);
+                    }
+                }
+                if (allAssocs.length >= limit)
+                    break;
+            }
+            return ok({
+                totalFound: allAssocs.length,
+                associations: allAssocs.slice(0, limit).map(mapAssociation),
+            });
+        }
+        const res = await apiFetchValidated(url, GwasEmbeddedSchema, { headers: GWAS_HEADERS });
+        if (res.isErr())
+            throw new Error(describeApiError(res.error));
+        const rawAssocs = res.value?._embedded?.associations ?? [];
+        const totalFound = res.value?.page?.totalElements ?? rawAssocs.length;
+        const filtered = rawAssocs
+            .filter((a) => {
+            const p = (a.pvalueMantissa ?? 1) * Math.pow(10, a.pvalueExponent ?? 0);
+            return p <= pValueThreshold;
+        })
+            .slice(0, limit);
+        return ok({
+            totalFound,
+            associations: filtered.map(mapAssociation),
+        });
+    },
+});

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

@@ -0,0 +1,17 @@
+/**
+ * searchInteractions — query protein-protein interactions via STRING DB.
+ */
+import { getEnrichment, getInteractionPartners } from "../lib/string-client.js";
+type InteractionsOutput = {
+    enrichment: Awaited<ReturnType<typeof getEnrichment>>;
+} | {
+    interactions: Awaited<ReturnType<typeof getInteractionPartners>>;
+};
+export declare const searchInteractionsTool: import("../define-tool.js").Tool<{
+    identifiers: string[];
+    species: number;
+    action: "partners" | "network" | "enrichment";
+    minScore: number;
+    limit: number;
+}, InteractionsOutput>;
+export {};

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

@@ -0,0 +1,31 @@
+/**
+ * searchInteractions — query protein-protein interactions via STRING DB.
+ */
+import { ok } from "neverthrow";
+import { z } from "zod";
+import { defineTool } from "../define-tool.js";
+import { getEnrichment, getInteractionNetwork, getInteractionPartners } from "../lib/string-client.js";
+export const searchInteractionsTool = defineTool({
+    id: "search_interactions",
+    description: "Query protein-protein interactions from STRING DB. " +
+        "Actions: 'partners' finds interaction partners for proteins, " +
+        "'network' gets the full interaction network between listed proteins, " +
+        "'enrichment' returns functional enrichment analysis (GO, KEGG, Reactome).",
+    inputSchema: z.object({
+        identifiers: z.array(z.string()).min(1).max(100).describe("Protein/gene identifiers (e.g. ['TP53', 'BRCA1'])"),
+        species: z.number().int().default(9606).describe("NCBI Taxonomy ID (9606 = human, 10090 = mouse)"),
+        action: z.enum(["partners", "network", "enrichment"]).default("partners").describe("Query type"),
+        minScore: z.number().int().min(0).max(1000).default(400).describe("Minimum confidence score (400=medium, 700=high, 900=highest)"),
+        limit: z.number().int().min(1).max(100).default(20).describe("Max interaction partners (partners action only)"),
+    }),
+    execute: async ({ identifiers, species, action, minScore, limit }) => {
+        if (action === "enrichment") {
+            const enrichment = await getEnrichment(identifiers, species);
+            return ok({ enrichment });
+        }
+        const interactions = action === "partners"
+            ? await getInteractionPartners(identifiers, { species, minScore, limit })
+            : await getInteractionNetwork(identifiers, { species, minScore });
+        return ok({ interactions });
+    },
+});

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

@@ -0,0 +1,11 @@
+/**
+ * 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

@@ -0,0 +1,25 @@
+/**
+ * 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-pathway.d.ts

@@ -0,0 +1,12 @@
+/**
+ * searchPathway — search biological pathways via KEGG and Reactome.
+ */
+export declare const searchPathwayTool: import("../define-tool.js").Tool<{
+    query: string;
+    source: "kegg" | "reactome" | "both";
+    organism: string;
+    includeGenes: boolean;
+    maxResults: number;
+}, {
+    pathways: import("../lib/pathway-client.js").Pathway[];
+}>;

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

@@ -0,0 +1,32 @@
+/**
+ * searchPathway — search biological pathways via KEGG and Reactome.
+ */
+import { ok } from "neverthrow";
+import { z } from "zod";
+import { defineTool } from "../define-tool.js";
+import { searchPathways } from "../lib/pathway-client.js";
+export const searchPathwayTool = defineTool({
+    id: "search_pathway",
+    description: "Search biological pathways in KEGG and/or Reactome databases. " +
+        "Returns pathway IDs, names, URLs, and optionally gene lists. " +
+        "Use source='both' to query both databases in parallel.",
+    inputSchema: z.object({
+        query: z.string().min(1).describe("Pathway search term (e.g. 'apoptosis', 'MAPK signaling')"),
+        source: z.enum(["kegg", "reactome", "both"]).default("both").describe("Which database to search"),
+        organism: z
+            .string()
+            .default("hsa")
+            .describe("KEGG organism code (e.g. 'hsa' for human, 'mmu' for mouse). " + "Automatically mapped to species name for Reactome."),
+        includeGenes: z.boolean().default(false).describe("Whether to fetch gene lists for each pathway (slower)"),
+        maxResults: z.number().int().min(1).max(50).default(10),
+    }),
+    execute: async ({ query, source, organism, includeGenes, maxResults }) => {
+        const pathways = await searchPathways(query, {
+            source,
+            organism,
+            includeGenes,
+            maxResults,
+        });
+        return ok({ pathways });
+    },
+});

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

@@ -0,0 +1,17 @@
+/**
+ * searchPharmgkb — search PharmGKB for pharmacogenomic clinical annotations.
+ */
+export declare const searchPharmgkbTool: import("../define-tool.js").Tool<{
+    query: string;
+    searchType: "drug" | "gene";
+    limit: number;
+}, {
+    annotations: {
+        gene: string;
+        drug: string;
+        phenotype: null;
+        levelOfEvidence: string;
+        guidelineSource: null;
+        summary: null;
+    }[];
+}>;

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

@@ -0,0 +1,46 @@
+/**
+ * searchPharmgkb — search PharmGKB for pharmacogenomic clinical annotations.
+ */
+import { ok } from "neverthrow";
+import { z } from "zod";
+import { defineTool } from "../define-tool.js";
+import { apiFetchValidated, describeApiError } from "../lib/api-utils.js";
+import { PHARMGKB_BASE, PHARMGKB_HEADERS } from "../lib/pharmgkb-config.js";
+// Raw PharmGKB clinicalAnnotation wire shape, validated at the fetch boundary.
+// Every field is optional because the API omits absent values; the mapper in
+// `execute` folds request context (`query`) into its output, so the schema
+// models only the raw wire and the mapping stays where it is.
+const PharmgkbAnnotationSchema = z.object({
+    location: z.object({ genes: z.array(z.object({ symbol: z.string().optional() })).optional() }).optional(),
+    relatedChemicals: z.array(z.object({ name: z.string().optional() })).optional(),
+    levelOfEvidence: z.object({ term: z.string().optional() }).optional(),
+});
+const PharmgkbResponseSchema = z.object({
+    data: z.array(PharmgkbAnnotationSchema).optional(),
+});
+export const searchPharmgkbTool = defineTool({
+    id: "search_pharmgkb",
+    description: "Search PharmGKB for pharmacogenomic clinical annotations — gene-drug interactions, dosing guidelines (CPIC/DPWG), and variant-level clinical significance. Use to determine if a gene variant affects drug metabolism, efficacy, or toxicity.",
+    inputSchema: z.object({
+        query: z.string().describe("Gene symbol (e.g. CYP2D6) or drug name (e.g. tamoxifen)"),
+        searchType: z.enum(["gene", "drug"]).describe("Search by gene or drug"),
+        limit: z.number().int().min(1).max(50).default(20).describe("Max results"),
+    }),
+    execute: async ({ query, searchType, limit = 20 }) => {
+        const filter = searchType === "gene" ? `location.genes.symbol=${encodeURIComponent(query)}` : `relatedChemicals.name=${encodeURIComponent(query)}`;
+        const endpoint = `${PHARMGKB_BASE}/clinicalAnnotation?${filter}`;
+        const res = await apiFetchValidated(endpoint, PharmgkbResponseSchema, { headers: PHARMGKB_HEADERS });
+        if (res.isErr())
+            throw new Error(describeApiError(res.error));
+        const data = res.value?.data ?? [];
+        const annotations = data.slice(0, limit).map((ann) => ({
+            gene: ann.location?.genes?.map((g) => g.symbol).join(", ") ?? query,
+            drug: ann.relatedChemicals?.map((c) => c.name).join(", ") ?? "",
+            phenotype: null,
+            levelOfEvidence: ann.levelOfEvidence?.term ?? "Unknown",
+            guidelineSource: null,
+            summary: null,
+        }));
+        return ok({ annotations });
+    },
+});

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

@@ -0,0 +1,26 @@
+/**
+ * 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

@@ -0,0 +1,110 @@
+/**
+ * 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

@@ -0,0 +1,17 @@
+/**
+ * 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

@@ -0,0 +1,31 @@
+/**
+ * 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

@@ -0,0 +1,9 @@
+/**
+ * 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

@@ -0,0 +1,20 @@
+/**
+ * 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

@@ -0,0 +1,36 @@
+/**
+ * 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 {};