@inflexa-ai/harness 0.1.1 → 0.3.0

package/dist/tools/bio/comptox.js

@@ -0,0 +1,149 @@
+/**
+ * comptox — the single EPA CompTox (CTX) tool: ToxCast/Tox21 bioactivity,
+ * in-vivo hazard, chemical identity + physchem, and exposure behind one
+ * `dataset` discriminator.
+ *
+ * All four datasets key off the same chemical resolution and the same
+ * EPA_CCTE_API_KEY, so the key contract is stated once in the description
+ * rather than four times.
+ *
+ * The input is a flat object with a `dataset` discriminator — not a
+ * `z.discriminatedUnion`, which `defineTool` rejects (the model needs a
+ * top-level `"type":"object"`). `dataType` and `limit` mean different things
+ * per dataset, so `.refine` guards reject a value that belongs to another
+ * dataset (a 'toxval' under dataset 'exposure' would otherwise silently fetch
+ * nothing) and a limit above the dataset's own ceiling.
+ */
+import { ok } from "neverthrow";
+import { z } from "zod";
+import { defineTool } from "../define-tool.js";
+import { fetchCtxChemicalDetail, fetchCtxChemicalProperties, fetchCtxExposureData, fetchCtxHazardData, fetchToxcastBioactivity, resolveDtxsid, } from "../lib/ctx-ops.js";
+import { getEpaCcteHeaders } from "../lib/toxcast-config.js";
+const HAZARD_DATA_TYPES = ["toxval", "genetox", "cancer", "all"];
+const EXPOSURE_DATA_TYPES = ["seem", "httk", "functional-use", "product-data", "all"];
+function isHazardDataType(value) {
+    return value !== undefined && HAZARD_DATA_TYPES.includes(value);
+}
+function isExposureDataType(value) {
+    return value !== undefined && EXPOSURE_DATA_TYPES.includes(value);
+}
+const inputSchema = z
+    .object({
+    dataset: z
+        .enum(["toxcast", "hazard", "chemical", "exposure"])
+        .describe("Which CompTox dataset to query. " +
+        "'toxcast' — ToxCast/Tox21 in-vitro high-throughput screening; profiles toxicological liability across hundreds of assay endpoints (nuclear receptors, stress response, " +
+        "mitochondrial toxicity), e.g. 'is this compound an endocrine disruptor?'. Returns the resolved chemical plus assay results — endpoint name, AC50, hit call, sorted by " +
+        "AC50 ascending — alongside totalAssays, activeAssays and activeHitRate, which always describe the full tested panel rather than the returned slice. " +
+        "'hazard' — ToxValDB / ToxRefDB IN-VIVO hazard: the points of departure a safety evaluation rests on. Returns dose-response rows (toxvalType such as NOAEL/LOAEL/LD50/BMD, " +
+        "with value, units, study type and duration, species, exposure route, effect), genotoxicity assay summaries, and cancer classifications. " +
+        "'chemical' — identity and physicochemical property profile from the CompTox Chemicals Dashboard, and the way to obtain the DTXSID the other datasets key off. Returns " +
+        "DTXSID, CASRN, SMILES, InChIKey, formula and mass, plus (unless includeProperties is false) experimental and predicted property summaries — logP, water solubility, " +
+        "vapor pressure, melting/boiling point, bioconcentration factor, Henry's law constant. " +
+        "'exposure' — the exposure half of a risk assessment (e.g. pairing a ToxCast AC50 against predicted exposure for a bioactivity-exposure ratio). Returns SEEM predictions " +
+        "(production volume and per-pathway exposure probabilities — dietary, residential, pesticide, industrial; NOT a daily-intake dose), HTTK toxicokinetic parameters, " +
+        "reported functional-use categories, and consumer-product composition."),
+    query: z
+        .string()
+        .describe("Chemical identifier (all datasets). A DTXSID (e.g. 'DTXSID7020182') is used directly with no lookup; a CASRN (e.g. '80-05-7'), a chemical name (e.g. 'bisphenol A'), " +
+        "or — for dataset 'chemical' — an InChIKey is resolved by EXACT match, so a non-canonical or misspelled name yields found: false."),
+    dataType: z
+        .enum(["toxval", "genetox", "cancer", "seem", "httk", "functional-use", "product-data", "all"])
+        .optional()
+        .describe("Which sections to fetch — datasets 'hazard' and 'exposure' only; ignored by 'toxcast' and 'chemical', which each return one dataset. Default 'all'. " +
+        "For dataset 'hazard': 'toxval' (ToxValDB dose-response values — NOAELs, LOAELs, LD50s, BMDs), 'genetox' (genotoxicity assay summaries), 'cancer' (cancer " +
+        "classifications — IARC/EPA/NTP and similar), or 'all'. " +
+        "For dataset 'exposure': 'seem' (SEEM exposure-pathway predictions and production volume), 'httk' (high-throughput toxicokinetic parameters — clearance, Css, protein " +
+        "binding, …), 'functional-use' (reported chemical use categories), 'product-data' (consumer-product composition), or 'all'. " +
+        "'all' fetches every section of that dataset concurrently."),
+    activeOnly: z
+        .boolean()
+        .optional()
+        .describe("Dataset 'toxcast' only. Default true — return only hit (active) assays. Set false for the whole tested panel including inactives, needed to judge selectivity or a low hit rate."),
+    includeProperties: z
+        .boolean()
+        .optional()
+        .describe("Dataset 'chemical' only. Default true — also fetch the experimental/predicted property summaries. Set false to skip that second call when only identity and mass are needed."),
+    limit: z
+        .number()
+        .int()
+        .min(1)
+        .max(200)
+        .optional()
+        .describe("Max rows returned; ignored by dataset 'chemical'. Defaults and ceilings differ per dataset: 'toxcast' default 50, max 200, applied after the activeOnly filter; " +
+        "'hazard' default 30, max 100, applied to toxval and genetox only — cancer ALWAYS returns every row; 'exposure' default 25, max 100, applied to functional-use and " +
+        "product-data only — seem and httk are ALWAYS returned whole."),
+})
+    .refine((d) => (d.dataset !== "toxcast" && d.dataset !== "chemical") || d.dataType === undefined || d.dataType === "all", {
+    message: "dataType applies only to dataset 'hazard' (toxval | genetox | cancer) and dataset 'exposure' (seem | httk | functional-use | product-data) — " +
+        "'toxcast' and 'chemical' each return one dataset. Select the dataset that owns the sections you want.",
+    path: ["dataType"],
+})
+    .refine((d) => d.dataset !== "hazard" || d.dataType === undefined || isHazardDataType(d.dataType), {
+    message: "dataType must be 'toxval', 'genetox', 'cancer', or 'all' when dataset is 'hazard' — " +
+        "seem / httk / functional-use / product-data belong to dataset 'exposure'.",
+    path: ["dataType"],
+})
+    .refine((d) => d.dataset !== "exposure" || d.dataType === undefined || isExposureDataType(d.dataType), {
+    message: "dataType must be 'seem', 'httk', 'functional-use', 'product-data', or 'all' when dataset is 'exposure' — " +
+        "toxval / genetox / cancer belong to dataset 'hazard'.",
+    path: ["dataType"],
+})
+    .refine((d) => d.dataset === "toxcast" || d.limit === undefined || d.limit <= 100, {
+    message: "limit is capped at 100 for datasets 'hazard' and 'exposure' (only 'toxcast' accepts up to 200)",
+    path: ["limit"],
+});
+export function createComptoxTool(deps) {
+    return defineTool({
+        id: "comptox",
+        description: "Query EPA's CompTox (CTX) chemical-safety databases — pick the dataset with `dataset`: 'toxcast' (in-vitro HTS bioactivity), 'hazard' (in-vivo hazard: NOAEL/LOAEL/LD50, " +
+            "genotoxicity, cancer classifications), 'chemical' (identity + physicochemical/ADMET properties), 'exposure' (SEEM exposure predictions, toxicokinetics, uses, products). " +
+            "See `dataset` for what each returns. Every dataset resolves the same `query` (DTXSID, CASRN, or exact chemical name) to a DTXSID first. " +
+            "Requires EPA_CCTE_API_KEY — a missing key fails the call terminally: do NOT retry, tell the user the key needs configuring and proceed without EPA data. " +
+            "found: false means the query did not resolve to a chemical — valid no-data, do not retry the same string; a present-but-empty section is likewise valid no-data. " +
+            "This is environmental/industrial-chemical safety data: for drug-like compounds prefer the PubChem or ChEMBL tools — dataset 'chemical' returns `detail.pubchemCid`, which " +
+            "bridges back to them.",
+        inputSchema,
+        execute: async (input) => {
+            const headers = getEpaCcteHeaders(deps.apiKey);
+            const resolved = await resolveDtxsid(input.query, headers);
+            // "No chemical found" is an expected outcome — a data variant, not an error.
+            if (!resolved)
+                return ok({ found: false, query: input.query });
+            const { dtxsid, preferredName, casrn } = resolved;
+            switch (input.dataset) {
+                case "toxcast": {
+                    const bioactivity = await fetchToxcastBioactivity(dtxsid, headers, {
+                        activeOnly: input.activeOnly ?? true,
+                        limit: input.limit ?? 50,
+                    });
+                    return ok({ found: true, chemical: { dtxsid, preferredName, casrn, ...bioactivity } });
+                }
+                case "hazard": {
+                    const data = await fetchCtxHazardData(dtxsid, headers, {
+                        dataType: isHazardDataType(input.dataType) ? input.dataType : "all",
+                        limit: input.limit ?? 30,
+                    });
+                    return ok({ found: true, dtxsid, preferredName, ...data });
+                }
+                case "chemical": {
+                    const detail = await fetchCtxChemicalDetail(dtxsid, headers);
+                    const result = { found: true, detail };
+                    if (input.includeProperties ?? true) {
+                        const properties = await fetchCtxChemicalProperties(dtxsid, headers);
+                        if (properties)
+                            result.properties = properties;
+                    }
+                    return ok(result);
+                }
+                case "exposure": {
+                    const data = await fetchCtxExposureData(dtxsid, headers, {
+                        dataType: isExposureDataType(input.dataType) ? input.dataType : "all",
+                        limit: input.limit ?? 25,
+                    });
+                    return ok({ found: true, dtxsid, ...data });
+                }
+            }
+        },
+    });
+}

package/dist/tools/bio/get-impc-ko-profile.js

@@ -8,13 +8,16 @@ import { buildViabilityCalls, derivedViability, getKoPhenotypeProfile, parsePhen
 export { buildViabilityCalls, derivedViability, parsePhenotypeResponse };
 export const getImpcKoProfileTool = defineTool({
     id: "get_impc_ko_profile",
-    description: "Get mouse knockout phenotype profile from IMPC: significant phenotype terms, " +
-        "affected organ systems, sex-dimorphism, and pre-weaning viability " +
-        "(lethal / subviable / viable, with per-zygosity breakdown). " +
-        "Use to assess loss-of-function consequences and target tractability. " +
-        "Single human gene symbol per call.",
+    description: "Get the mouse-knockout phenotype profile for a gene from IMPC — the in-vivo loss-of-function evidence for target tractability and essentiality " +
+        "('what happens to PAX5 knockout mice?', 'is loss of CASP8 lethal?'). " +
+        "Takes a human gene symbol and maps it to the mouse ortholog itself. Returns a top-line pre-weaning viability call (lethal_pre_weaning | subviable | viable | null) with its " +
+        "per-zygosity breakdown, the significant MP phenotype terms ordered by best p-value, the affected organ systems ranked by phenotype count, and a sex-dimorphism flag. " +
+        "An all-empty profile (null mouseMarkerSymbol, null viability, no phenotype terms) means the gene has not been IMPC-phenotyped — common and valid. Do NOT retry on empty output.",
     inputSchema: z.object({
-        geneSymbol: z.string().min(1).describe("Human gene symbol, e.g. 'BRCA1'."),
+        geneSymbol: z
+            .string()
+            .min(1)
+            .describe("HUMAN gene symbol, e.g. 'BRCA1' — one gene per call. The mouse ortholog is resolved internally; do not pass a mouse symbol or an MGI ID."),
     }),
     execute: async ({ geneSymbol }) => ok(await getKoPhenotypeProfile(geneSymbol)),
 });

package/dist/tools/bio/index.d.ts

@@ -10,19 +10,10 @@ export * from "./search-gene.js";
 export * from "./search-pathway.js";
 export * from "./lookup-go-term.js";
 export * from "./search-interactions.js";
-export * from "./search-pubmed.js";
-export * from "./get-article-details.js";
-export * from "./get-article-full-text.js";
-export * from "./search-compounds.js";
-export * from "./get-bioactivity.js";
-export * from "./search-targets.js";
-export * from "./get-mechanism.js";
-export * from "./get-drug-info.js";
-export * from "./search-pubchem-compound.js";
-export * from "./get-pubchem-cross-refs.js";
-export * from "./get-pubchem-assays.js";
-export * from "./search-opentargets.js";
-export * from "./get-target-safety.js";
+export * from "./pubmed.js";
+export * from "./chembl.js";
+export * from "./pubchem.js";
+export * from "./opentargets.js";
 export * from "./search-pharmgkb.js";
 export * from "./search-faers.js";
 export * from "./search-clinical-trials.js";
@@ -35,7 +26,4 @@ export * from "./search-gwas-catalog.js";
 export * from "./search-bgee-expression.js";
 export * from "./get-impc-ko-profile.js";
 export * from "./check-safety-panel.js";
-export * from "./search-toxcast.js";
-export * from "./search-ctx-hazard.js";
-export * from "./search-ctx-chemical.js";
-export * from "./search-ctx-exposure.js";
+export * from "./comptox.js";

package/dist/tools/bio/index.js

@@ -12,22 +12,13 @@ export * from "./search-pathway.js";
 export * from "./lookup-go-term.js";
 export * from "./search-interactions.js";
 // Literature
-export * from "./search-pubmed.js";
-export * from "./get-article-details.js";
-export * from "./get-article-full-text.js";
+export * from "./pubmed.js";
 // ChEMBL
-export * from "./search-compounds.js";
-export * from "./get-bioactivity.js";
-export * from "./search-targets.js";
-export * from "./get-mechanism.js";
-export * from "./get-drug-info.js";
+export * from "./chembl.js";
 // PubChem
-export * from "./search-pubchem-compound.js";
-export * from "./get-pubchem-cross-refs.js";
-export * from "./get-pubchem-assays.js";
+export * from "./pubchem.js";
 // Translational medicine
-export * from "./search-opentargets.js";
-export * from "./get-target-safety.js";
+export * from "./opentargets.js";
 export * from "./search-pharmgkb.js";
 export * from "./search-faers.js";
 export * from "./search-clinical-trials.js";
@@ -42,7 +33,4 @@ export * from "./search-bgee-expression.js";
 export * from "./get-impc-ko-profile.js";
 // Off-target liability / EPA CompTox
 export * from "./check-safety-panel.js";
-export * from "./search-toxcast.js";
-export * from "./search-ctx-hazard.js";
-export * from "./search-ctx-chemical.js";
-export * from "./search-ctx-exposure.js";
+export * from "./comptox.js";

package/dist/tools/bio/keys.d.ts

@@ -13,19 +13,24 @@ export interface BioToolKeys {
     readonly ncbi?: string;
     readonly github?: string;
 }
-/** The NCBI-backed literature tools, built from the shared key slice. */
+/**
+ * The NCBI-backed literature tools, built from the shared key slice.
+ *
+ * `pubmed` is the consolidated literature tool (search / details / fulltext
+ * behind one `action`); `searchClinvar` remains its own single-endpoint tool.
+ */
 export declare function createNcbiTools(keys: BioToolKeys): {
-    searchPubMed: Tool;
-    getArticleDetails: Tool;
-    getArticleFullText: Tool;
+    pubmed: Tool;
     searchClinvar: Tool;
 };
-/** The DrugBank / DisGeNET / EPA CompTox tools, built from the key slice. */
+/**
+ * The DrugBank / DisGeNET / EPA CompTox tools, built from the key slice.
+ *
+ * `comptox` is the consolidated EPA CTX tool (toxcast / hazard / chemical /
+ * exposure behind one `dataset`), built over the shared EPA_CCTE key.
+ */
 export declare function createChemDbTools(keys: BioToolKeys): {
     searchDrugbank: Tool;
     searchDisgenet: Tool;
-    searchToxcast: Tool;
-    searchCtxHazard: Tool;
-    searchCtxChemical: Tool;
-    searchCtxExposure: Tool;
+    comptox: Tool;
 };

package/dist/tools/bio/keys.js

@@ -1,30 +1,30 @@
-import { createSearchPubMedTool } from "./search-pubmed.js";
-import { createGetArticleDetailsTool } from "./get-article-details.js";
-import { createGetArticleFullTextTool } from "./get-article-full-text.js";
+import { createPubMedTool } from "./pubmed.js";
 import { createSearchClinvarTool } from "./search-clinvar.js";
 import { createSearchDrugbankTool } from "./search-drugbank.js";
 import { createSearchDisgenetTool } from "./search-disgenet.js";
-import { createSearchToxcastTool } from "./search-toxcast.js";
-import { createSearchCtxHazardTool } from "./search-ctx-hazard.js";
-import { createSearchCtxChemicalTool } from "./search-ctx-chemical.js";
-import { createSearchCtxExposureTool } from "./search-ctx-exposure.js";
-/** The NCBI-backed literature tools, built from the shared key slice. */
+import { createComptoxTool } from "./comptox.js";
+/**
+ * The NCBI-backed literature tools, built from the shared key slice.
+ *
+ * `pubmed` is the consolidated literature tool (search / details / fulltext
+ * behind one `action`); `searchClinvar` remains its own single-endpoint tool.
+ */
 export function createNcbiTools(keys) {
     return {
-        searchPubMed: createSearchPubMedTool({ ncbiApiKey: keys.ncbi }),
-        getArticleDetails: createGetArticleDetailsTool({ ncbiApiKey: keys.ncbi }),
-        getArticleFullText: createGetArticleFullTextTool({ ncbiApiKey: keys.ncbi }),
+        pubmed: createPubMedTool({ ncbiApiKey: keys.ncbi }),
         searchClinvar: createSearchClinvarTool({ ncbiApiKey: keys.ncbi }),
     };
 }
-/** The DrugBank / DisGeNET / EPA CompTox tools, built from the key slice. */
+/**
+ * The DrugBank / DisGeNET / EPA CompTox tools, built from the key slice.
+ *
+ * `comptox` is the consolidated EPA CTX tool (toxcast / hazard / chemical /
+ * exposure behind one `dataset`), built over the shared EPA_CCTE key.
+ */
 export function createChemDbTools(keys) {
     return {
         searchDrugbank: createSearchDrugbankTool({ apiKey: keys.drugbank }),
         searchDisgenet: createSearchDisgenetTool({ apiKey: keys.disgenet }),
-        searchToxcast: createSearchToxcastTool({ apiKey: keys.epaCcte }),
-        searchCtxHazard: createSearchCtxHazardTool({ apiKey: keys.epaCcte }),
-        searchCtxChemical: createSearchCtxChemicalTool({ apiKey: keys.epaCcte }),
-        searchCtxExposure: createSearchCtxExposureTool({ apiKey: keys.epaCcte }),
+        comptox: createComptoxTool({ apiKey: keys.epaCcte }),
     };
 }

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

@@ -0,0 +1,38 @@
+/**
+ * opentargets — one tool over the Open Targets Platform: target-disease
+ * association evidence (from a gene or from a disease) and the target's
+ * curated safety liabilities.
+ *
+ * The input is a flat object with an `action` discriminator — not a
+ * `z.discriminatedUnion`, which `defineTool` rejects (model tool calling needs
+ * a top-level `"type":"object"`). Each action's identifier is optional in the
+ * schema and enforced by `.refine`, so a call that omits it fails at the loop
+ * boundary with an actionable message instead of reaching the API.
+ *
+ * The identifier fields are deliberately separate (`ensemblId` / `efoId`)
+ * rather than one polymorphic `query`: Open Targets accepts ONLY an Ensembl
+ * gene ID or an EFO disease ID, and a gene symbol silently returns an empty
+ * result rather than an error. Naming the two identifiers apart is what makes
+ * that contract visible at the call site.
+ */
+import { type Association, type SafetyLiability, type TargetInfo } from "../lib/opentargets-client.js";
+type OpenTargetsOutput = {
+    targetInfo: TargetInfo | null;
+    associations: Association[];
+} | {
+    associations: Association[];
+} | {
+    found: false;
+    ensemblId: string;
+} | {
+    found: true;
+    targetSymbol: string;
+    safetyLiabilities: SafetyLiability[];
+};
+export declare const openTargetsTool: import("../define-tool.js").Tool<{
+    action: "target" | "disease" | "safety";
+    ensemblId?: string | undefined;
+    efoId?: string | undefined;
+    limit?: number | undefined;
+}, OpenTargetsOutput>;
+export {};

package/dist/tools/bio/opentargets.js

@@ -0,0 +1,89 @@
+/**
+ * opentargets — one tool over the Open Targets Platform: target-disease
+ * association evidence (from a gene or from a disease) and the target's
+ * curated safety liabilities.
+ *
+ * The input is a flat object with an `action` discriminator — not a
+ * `z.discriminatedUnion`, which `defineTool` rejects (model tool calling needs
+ * a top-level `"type":"object"`). Each action's identifier is optional in the
+ * schema and enforced by `.refine`, so a call that omits it fails at the loop
+ * boundary with an actionable message instead of reaching the API.
+ *
+ * The identifier fields are deliberately separate (`ensemblId` / `efoId`)
+ * rather than one polymorphic `query`: Open Targets accepts ONLY an Ensembl
+ * gene ID or an EFO disease ID, and a gene symbol silently returns an empty
+ * result rather than an error. Naming the two identifiers apart is what makes
+ * that contract visible at the call site.
+ */
+import { ok } from "neverthrow";
+import { z } from "zod";
+import { defineTool } from "../define-tool.js";
+import { getTargetSafetyLiabilities, searchDiseaseAssociations, searchTargetAssociations, } from "../lib/opentargets-client.js";
+const inputSchema = z
+    .object({
+    action: z
+        .enum(["target", "disease", "safety"])
+        .describe("'target' (needs ensemblId) — the diseases associated with the gene: targetInfo (approvedSymbol, approvedName, " +
+        "tractability across small molecule / antibody / other modalities) plus associations[], each with an overall score and " +
+        "its per-datatype breakdown — genetic association, known drug, literature, animal model, somatic mutation. " +
+        "'disease' (needs efoId) — the targets ranked for that disease; each association carries targetId/targetSymbol/targetName " +
+        "and the same score breakdown. " +
+        "'safety' (needs ensemblId) — the target's curated safety liabilities: found: true with targetSymbol and " +
+        "safetyLiabilities[] { event, biosamples (affected tissues), effects (direction of effect), source }. This is TARGET-level, " +
+        "mechanism-based safety — for the post-market adverse events of a specific marketed DRUG use search_faers instead."),
+    ensemblId: z.string().optional().describe("Ensembl gene ID, e.g. ENSG00000141510 (TP53). Required for action 'target' and 'safety'."),
+    efoId: z.string().optional().describe("EFO disease ID, e.g. EFO_0000311. Required for action 'disease'."),
+    limit: z
+        .number()
+        .int()
+        .min(1)
+        .max(100)
+        .default(25)
+        .optional()
+        .describe("Max associations to return (default 25, max 100), ordered by descending association score. Ignored by 'safety'."),
+})
+    .refine((d) => d.action === "disease" || (d.ensemblId !== undefined && d.ensemblId.trim().length > 0), {
+    message: "ensemblId is required when action is 'target' or 'safety' — Open Targets accepts only Ensembl gene IDs (ENSG…), " +
+        "never gene symbols. Resolve the symbol to an ENSG id with search_gene, then retry.",
+    path: ["ensemblId"],
+})
+    .refine((d) => d.action !== "disease" || (d.efoId !== undefined && d.efoId.trim().length > 0), {
+    message: "efoId is required when action is 'disease' — Open Targets accepts only EFO disease IDs (e.g. EFO_0000311), never free-text disease names.",
+    path: ["efoId"],
+});
+export const openTargetsTool = defineTool({
+    id: "opentargets",
+    description: "Query the Open Targets Platform — the preferred FIRST call for target assessment, since one 'target' query yields the " +
+        "genetic evidence, tractability, and drug landscape together, and 'safety' adds the mechanism-based liabilities. See the " +
+        "action parameter for what each mode needs and returns.\n" +
+        "IDENTIFIERS ONLY: it accepts an Ensembl gene ID (action 'target'/'safety') or an EFO disease ID (action 'disease'). A bare " +
+        "gene symbol or a free-text disease name silently returns an EMPTY result rather than an error — resolve a symbol to its ENSG " +
+        "id with search_gene first.\n" +
+        "NO-DATA IS FINAL — do not retry the same id. Empty associations mean no evidence (or an unresolvable id); safety found: false " +
+        "means no Open Targets record for that Ensembl id (usually a wrong id); safety found: true with an empty safetyLiabilities " +
+        "array means no curated liability.",
+    inputSchema,
+    execute: async (input) => {
+        switch (input.action) {
+            case "target": {
+                const targetInfo = await searchTargetAssociations(input.ensemblId, input.limit);
+                return ok({ targetInfo, associations: targetInfo?.associations ?? [] });
+            }
+            case "disease": {
+                const associations = await searchDiseaseAssociations(input.efoId, input.limit);
+                return ok({ associations });
+            }
+            case "safety": {
+                const result = await getTargetSafetyLiabilities(input.ensemblId);
+                // "Target not found" is an expected outcome — a data variant, not an error.
+                if (!result)
+                    return ok({ found: false, ensemblId: input.ensemblId });
+                return ok({
+                    found: true,
+                    targetSymbol: result.targetSymbol,
+                    safetyLiabilities: result.safetyLiabilities,
+                });
+            }
+        }
+    },
+});

package/dist/tools/bio/pubchem.d.ts

@@ -0,0 +1,29 @@
+/**
+ * pubchem — the single PubChem tool: compound resolution, registry
+ * cross-references, and bioassay screening summaries behind one `action`
+ * discriminator.
+ *
+ * The input is a flat object with an `action` discriminator — not a
+ * `z.discriminatedUnion`, which `defineTool` rejects (the model needs a
+ * top-level `"type":"object"`). Each action's own parameters are optional and
+ * guarded by `.refine`, so a call that omits one (a 'crossrefs' with no `cid`)
+ * fails at the loop boundary with a message naming the missing field, rather
+ * than reaching an upstream request that cannot be built.
+ */
+import { type PubChemAssay, type PubChemCompound, type PubChemCrossRef } from "../lib/pubchem-ops.js";
+type PubchemOutput = {
+    results: PubChemCompound[];
+} | {
+    crossRefs: PubChemCrossRef[];
+} | {
+    assays: PubChemAssay[];
+};
+export declare const pubchemTool: import("../define-tool.js").Tool<{
+    action: "compound" | "crossrefs" | "assays";
+    query?: string | undefined;
+    searchBy?: "name" | "smiles" | "inchikey" | "inchi" | "cid" | undefined;
+    cid?: number | undefined;
+    activeOnly?: boolean | undefined;
+    limit?: number | undefined;
+}, PubchemOutput>;
+export {};

package/dist/tools/bio/pubchem.js

@@ -0,0 +1,92 @@
+/**
+ * pubchem — the single PubChem tool: compound resolution, registry
+ * cross-references, and bioassay screening summaries behind one `action`
+ * discriminator.
+ *
+ * The input is a flat object with an `action` discriminator — not a
+ * `z.discriminatedUnion`, which `defineTool` rejects (the model needs a
+ * top-level `"type":"object"`). Each action's own parameters are optional and
+ * guarded by `.refine`, so a call that omits one (a 'crossrefs' with no `cid`)
+ * fails at the loop boundary with a message naming the missing field, rather
+ * than reaching an upstream request that cannot be built.
+ */
+import { ok } from "neverthrow";
+import { z } from "zod";
+import { defineTool } from "../define-tool.js";
+import { fetchPubchemAssays, fetchPubchemCompounds, fetchPubchemCrossRefs, } from "../lib/pubchem-ops.js";
+const inputSchema = z
+    .object({
+    action: z
+        .enum(["compound", "crossrefs", "assays"])
+        .describe("Which PubChem lookup to run. " +
+        "'compound' — resolve `query` (in the namespace named by `searchBy`) to a compound. Returns results[]: identity (cid, canonicalSmiles, inchi, inchiKey, iupacName, " +
+        "molecularFormula) and computed properties (molecularWeight, xlogp, tpsa, hbondDonorCount, hbondAcceptorCount, rotatableBondCount, complexity). " +
+        "'crossrefs' — external registry ids for a `cid`. Returns crossRefs[]: a flat list of { source, id } pairs across ChEMBL, DrugBank, KEGG, PDB and many other " +
+        "registries; filter by `source` for the one you want. This is the bridge out of PubChem. " +
+        "'assays' — bioassay screening summaries for a `cid`; answers 'has this compound ever been screened, and against what?'. Returns assays[]: aid, assayName, targetName, " +
+        "activityOutcome (Active / Inactive / Inconclusive / Unspecified), activityValue. Broad HTS screening coverage, NOT curated potency — for numbers you intend to quote " +
+        "(IC50/Ki), prefer chembl action='bioactivity'."),
+    query: z
+        .string()
+        .min(1)
+        .optional()
+        .describe("Required for action 'compound'. The identifier itself; its form must match `searchBy` (a name, a SMILES string, an InChI, an InChIKey, or a numeric CID)."),
+    searchBy: z
+        .enum(["name", "smiles", "inchi", "inchikey", "cid"])
+        .optional()
+        .describe("Required for action 'compound'. Which PubChem namespace `query` is expressed in. All are exact-match lookups except 'name', which tolerates synonyms and trade names."),
+    cid: z
+        .number()
+        .int()
+        .positive()
+        .optional()
+        .describe("Required for actions 'crossrefs' and 'assays'. PubChem Compound ID as an integer (e.g. 2244 for aspirin), from a prior action 'compound' call."),
+    activeOnly: z
+        .boolean()
+        .optional()
+        .describe("Action 'assays' only. Default false (all outcomes). Set true to keep only rows whose activityOutcome is 'Active'."),
+    limit: z
+        .number()
+        .int()
+        .min(1)
+        .max(500)
+        .optional()
+        .describe("Action 'assays' only. Max assay records to return (default 50, max 500). Applied after the activeOnly filter."),
+})
+    .refine((d) => d.action !== "compound" || (d.query !== undefined && d.query.trim().length > 0), {
+    message: "query is required when action is 'compound' — the identifier to resolve (a name, SMILES, InChI, InChIKey, or CID)",
+    path: ["query"],
+})
+    .refine((d) => d.action !== "compound" || d.searchBy !== undefined, {
+    message: "searchBy is required when action is 'compound' — name | smiles | inchi | inchikey | cid, matching the form of `query`",
+    path: ["searchBy"],
+})
+    .refine((d) => (d.action !== "crossrefs" && d.action !== "assays") || d.cid !== undefined, {
+    message: "cid is required when action is 'crossrefs' or 'assays' — resolve the compound with action 'compound' first and copy its cid",
+    path: ["cid"],
+});
+export const pubchemTool = defineTool({
+    id: "pubchem",
+    description: "Query PubChem (110M+ compounds) — pick the lookup with `action`: 'compound' (resolve an identifier), 'crossrefs' (external registry ids for a CID), 'assays' (bioassay screening " +
+        "summaries for a CID). See `action` for what each returns. " +
+        "Reach for PubChem when ChEMBL misses the compound — it covers metabolites, vendor chemicals, food additives and environmental compounds that ChEMBL does not. " +
+        "PubChem carries no curated mechanism or potency data, so resolve broadly HERE and then bridge OUT: action 'compound' to get the cid, action 'crossrefs' to take its ChEMBL ID, " +
+        "then chembl action='mechanism' / 'bioactivity' there for curated activity data. " +
+        "An empty results / crossRefs / assays array is valid no-data (no match; the CID is in no external registry; the compound was never screened) — do not retry.",
+    inputSchema,
+    execute: async (input) => {
+        switch (input.action) {
+            case "compound":
+                return ok({ results: await fetchPubchemCompounds(input.query, input.searchBy) });
+            case "crossrefs":
+                return ok({ crossRefs: await fetchPubchemCrossRefs(input.cid) });
+            case "assays":
+                return ok({
+                    assays: await fetchPubchemAssays(input.cid, {
+                        activeOnly: input.activeOnly ?? false,
+                        limit: input.limit ?? 50,
+                    }),
+                });
+        }
+    },
+});

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

@@ -0,0 +1,51 @@
+/**
+ * pubmed — one tool over PubMed and PubMed Central (NCBI E-utilities):
+ * search the literature, fetch article metadata, and read the full text of an
+ * open-access article.
+ *
+ * Dependency-bearing: the optional NCBI API key is captured by the factory.
+ *
+ * The input is a flat object with an `action` discriminator — not a
+ * `z.discriminatedUnion`, which `defineTool` rejects (model tool calling needs
+ * a top-level `"type":"object"`). Each action's required argument is optional
+ * in the schema and enforced by `.refine`, so a malformed call (e.g. 'fulltext'
+ * with no pmcId) fails at the loop boundary and surfaces as an `is_error` tool
+ * result instead of reaching NCBI.
+ *
+ * The three actions form one retrieval chain — search yields PMIDs, details
+ * turns PMIDs into abstracts + the PMC id, fulltext turns a PMC id into the
+ * article body — which is why they share a tool: the identifier for each step
+ * is read off the previous step's result.
+ */
+import type { ArticleSection } from "../lib/ncbi-utils.js";
+import { type ArticleDetail, type PubMedSummary } from "../lib/pubmed-client.js";
+type PubMedOutput = {
+    totalFound: number;
+    results: PubMedSummary[];
+} | {
+    articles: ArticleDetail[];
+    notFound: string[];
+} | {
+    pmcId: string;
+    available: false;
+} | {
+    pmcId: string;
+    available: true;
+    fullText: string;
+    sections: ArticleSection[];
+};
+export declare function createPubMedTool(deps: {
+    ncbiApiKey?: string;
+}): import("../define-tool.js").Tool<{
+    action: "search" | "details" | "fulltext";
+    query?: string | undefined;
+    maxResults?: number | undefined;
+    sort?: "date" | "relevance" | undefined;
+    dateRange?: {
+        from: string;
+        to: string;
+    } | undefined;
+    pmids?: string[] | undefined;
+    pmcId?: string | undefined;
+}, PubMedOutput>;
+export {};