@inflexa-ai/harness 0.1.1

package/dist/tools/bio/get-article-details.js

@@ -0,0 +1,20 @@
+/**
+ * getArticleDetails — fetch detailed metadata for PubMed articles.
+ */
+import { ok } from "neverthrow";
+import { z } from "zod";
+import { defineTool } from "../define-tool.js";
+import { getArticleDetails } from "../lib/pubmed-client.js";
+export function createGetArticleDetailsTool(deps) {
+    return defineTool({
+        id: "get_article_details",
+        description: "Fetch detailed metadata for PubMed articles by PMID. " +
+            "Returns title, full abstract, authors, journal, year, DOI, MeSH terms, " +
+            "and PMC ID (if open-access full text is available in PubMed Central). " +
+            "Accepts up to 20 PMIDs per call for batch retrieval.",
+        inputSchema: z.object({
+            pmids: z.array(z.string()).min(1).max(20).describe("PubMed IDs to fetch details for (max 20)"),
+        }),
+        execute: async ({ pmids }) => ok(await getArticleDetails(deps.ncbiApiKey, pmids)),
+    });
+}

package/dist/tools/bio/get-article-full-text.d.ts

@@ -0,0 +1,19 @@
+/**
+ * getArticleFullText — fetch full text of open-access articles from PMC.
+ */
+import type { ArticleSection } from "../lib/ncbi-utils.js";
+type FullTextResult = {
+    pmcId: string;
+    available: false;
+} | {
+    pmcId: string;
+    available: true;
+    fullText: string;
+    sections: ArticleSection[];
+};
+export declare function createGetArticleFullTextTool(deps: {
+    ncbiApiKey?: string;
+}): import("../define-tool.js").Tool<{
+    pmcId: string;
+}, FullTextResult>;
+export {};

package/dist/tools/bio/get-article-full-text.js

@@ -0,0 +1,32 @@
+/**
+ * getArticleFullText — fetch full text of open-access articles from PMC.
+ */
+import { ok } from "neverthrow";
+import { z } from "zod";
+import { defineTool } from "../define-tool.js";
+import { getArticleFullText } from "../lib/pubmed-client.js";
+export function createGetArticleFullTextTool(deps) {
+    return defineTool({
+        id: "get_article_full_text",
+        description: "Fetch the full text of an open-access article from PubMed Central (PMC). " +
+            "Accepts a PMC ID (e.g., 'PMC1234567') as returned by getArticleDetails. " +
+            "Returns the article body as plain text with section headers preserved. " +
+            "Only works for open-access articles available in PMC — check the pmcId " +
+            "field from getArticleDetails before calling this tool.",
+        inputSchema: z.object({
+            pmcId: z.string().describe('PubMed Central ID (e.g., "PMC1234567")'),
+        }),
+        execute: async ({ pmcId }) => {
+            const parsed = await getArticleFullText(deps.ncbiApiKey, pmcId);
+            // "Not open-access" is an expected outcome — a data variant, not an error.
+            if (!parsed)
+                return ok({ pmcId, available: false });
+            return ok({
+                pmcId,
+                available: true,
+                fullText: parsed.fullText,
+                sections: parsed.sections,
+            });
+        },
+    });
+}

package/dist/tools/bio/get-bioactivity.d.ts

@@ -0,0 +1,11 @@
+/**
+ * getBioactivity tool — retrieve bioactivity data (IC50, EC50, Ki) from ChEMBL.
+ */
+export declare const getBioactivityTool: import("../define-tool.js").Tool<{
+    chemblId: string;
+    type: "target" | "compound";
+    limit: number;
+    activityType?: string | undefined;
+}, {
+    activities: import("../lib/chembl-client.js").ChemblActivity[];
+}>;

package/dist/tools/bio/get-bioactivity.js

@@ -0,0 +1,23 @@
+/**
+ * getBioactivity tool — retrieve bioactivity data (IC50, EC50, Ki) from ChEMBL.
+ */
+import { ok } from "neverthrow";
+import { z } from "zod";
+import { defineTool } from "../define-tool.js";
+import { getBioactivity } from "../lib/chembl-client.js";
+export const getBioactivityTool = defineTool({
+    id: "get_bioactivity",
+    description: "Get bioactivity data (IC50, EC50, Ki, etc.) from ChEMBL for a compound or target. " +
+        "Returns activity values, assay information, and pChEMBL values. " +
+        "Optionally filter by activity type (e.g. 'IC50', 'EC50', 'Ki').",
+    inputSchema: z.object({
+        chemblId: z.string().min(1).describe("ChEMBL ID (e.g. 'CHEMBL25' for aspirin, 'CHEMBL203' for EGFR target)"),
+        type: z.enum(["compound", "target"]).describe("Whether the ChEMBL ID refers to a compound or a target"),
+        activityType: z.string().optional().describe("Filter by standard_type (e.g. 'IC50', 'EC50', 'Ki')"),
+        limit: z.number().int().min(1).max(500).default(500).describe("Maximum number of activity records to return"),
+    }),
+    execute: async ({ chemblId, type, activityType, limit }) => {
+        const activities = await getBioactivity(chemblId, type, { activityType, limit });
+        return ok({ activities });
+    },
+});

package/dist/tools/bio/get-drug-info.d.ts

@@ -0,0 +1,9 @@
+/**
+ * getDrugInfo tool — search ChEMBL for approved drugs by indication or name.
+ */
+export declare const getDrugInfoTool: import("../define-tool.js").Tool<{
+    query: string;
+    limit: number;
+}, {
+    drugs: import("../lib/chembl-client.js").ChemblDrug[];
+}>;

package/dist/tools/bio/get-drug-info.js

@@ -0,0 +1,22 @@
+/**
+ * getDrugInfo tool — search ChEMBL for approved drugs by indication or name.
+ */
+import { ok } from "neverthrow";
+import { z } from "zod";
+import { defineTool } from "../define-tool.js";
+import { getDrugInfo } from "../lib/chembl-client.js";
+export const getDrugInfoTool = defineTool({
+    id: "get_drug_info",
+    description: "Search ChEMBL for approved drugs by indication or drug name. " +
+        "Returns drug metadata including approval phase, molecule type, " +
+        "first approval year, and indications. Falls back to molecule search " +
+        "filtered by max_phase >= 4 if the drug endpoint yields no results.",
+    inputSchema: z.object({
+        query: z.string().min(1).describe("Drug name or indication to search for (e.g. 'imatinib', 'breast cancer')"),
+        limit: z.number().int().min(1).max(25).default(25).describe("Maximum number of results to return"),
+    }),
+    execute: async ({ query, limit }) => {
+        const drugs = await getDrugInfo(query, limit);
+        return ok({ drugs });
+    },
+});

package/dist/tools/bio/get-impc-ko-profile.d.ts

@@ -0,0 +1,9 @@
+/**
+ * getImpcKoProfile tool — mouse knockout phenotype profile via IMPC Solr.
+ */
+import { buildViabilityCalls, derivedViability, parsePhenotypeResponse } from "../lib/impc-client.js";
+export type { PhenotypeProfile, ViabilityCall, ViabilityCategory } from "../lib/impc-client.js";
+export { buildViabilityCalls, derivedViability, parsePhenotypeResponse };
+export declare const getImpcKoProfileTool: import("../define-tool.js").Tool<{
+    geneSymbol: string;
+}, import("../lib/impc-client.js").KoPhenotypeProfile>;

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

@@ -0,0 +1,20 @@
+/**
+ * getImpcKoProfile tool — mouse knockout phenotype profile via IMPC Solr.
+ */
+import { ok } from "neverthrow";
+import { z } from "zod";
+import { defineTool } from "../define-tool.js";
+import { buildViabilityCalls, derivedViability, getKoPhenotypeProfile, parsePhenotypeResponse } from "../lib/impc-client.js";
+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.",
+    inputSchema: z.object({
+        geneSymbol: z.string().min(1).describe("Human gene symbol, e.g. 'BRCA1'."),
+    }),
+    execute: async ({ geneSymbol }) => ok(await getKoPhenotypeProfile(geneSymbol)),
+});

package/dist/tools/bio/get-mechanism.d.ts

@@ -0,0 +1,8 @@
+/**
+ * getMechanism tool — retrieve mechanism of action data from ChEMBL.
+ */
+export declare const getMechanismTool: import("../define-tool.js").Tool<{
+    chemblId: string;
+}, {
+    mechanisms: import("../lib/chembl-client.js").ChemblMechanism[];
+}>;

package/dist/tools/bio/get-mechanism.js

@@ -0,0 +1,18 @@
+/**
+ * getMechanism tool — retrieve mechanism of action data from ChEMBL.
+ */
+import { ok } from "neverthrow";
+import { z } from "zod";
+import { defineTool } from "../define-tool.js";
+import { getMechanism } from "../lib/chembl-client.js";
+export const getMechanismTool = defineTool({
+    id: "get_mechanism",
+    description: "Get mechanism of action for a compound from ChEMBL. " + "Returns mechanism descriptions, action types, and associated target information.",
+    inputSchema: z.object({
+        chemblId: z.string().min(1).describe("Compound ChEMBL ID (e.g. 'CHEMBL25' for aspirin)"),
+    }),
+    execute: async ({ chemblId }) => {
+        const mechanisms = await getMechanism(chemblId);
+        return ok({ mechanisms });
+    },
+});

package/dist/tools/bio/get-pubchem-assays.d.ts

@@ -0,0 +1,22 @@
+/**
+ * getPubchemAssays tool — retrieve bioassay screening summaries for a PubChem CID.
+ *
+ * Returns per-assay activity outcomes (active/inactive/inconclusive),
+ * target names, and assay descriptions. Broader coverage than ChEMBL's
+ * curated bioactivity data.
+ */
+interface Assay {
+    aid: number;
+    assayName: string | null;
+    targetName: string | null;
+    activityOutcome: string | null;
+    activityValue: number | null;
+}
+export declare const getPubchemAssaysTool: import("../define-tool.js").Tool<{
+    cid: number;
+    activeOnly: boolean;
+    limit: number;
+}, {
+    assays: Assay[];
+}>;
+export {};

package/dist/tools/bio/get-pubchem-assays.js

@@ -0,0 +1,107 @@
+/**
+ * getPubchemAssays tool — retrieve bioassay screening summaries for a PubChem CID.
+ *
+ * Returns per-assay activity outcomes (active/inactive/inconclusive),
+ * target names, and assay descriptions. Broader coverage than ChEMBL's
+ * curated bioactivity data.
+ */
+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";
+// The PUG-REST assay-summary wire shape (a table of columns + rows), validated
+// at the fetch boundary; `parseAssaySummary` maps the heading-indexed cells into
+// `Assay` records. Every field is optional — PubChem omits absent values.
+const PugAssaySummarySchema = z.object({
+    Table: z
+        .object({
+        Columns: z
+            .object({
+            Column: z.array(z.object({ Heading: z.string().optional() })).optional(),
+        })
+            .optional(),
+        Row: z
+            .array(z.object({
+            Cell: z
+                .array(z.object({
+                intval: z.number().optional(),
+                fval: z.number().optional(),
+                sval: z.string().optional(),
+            }))
+                .optional(),
+        }))
+            .optional(),
+    })
+        .optional(),
+});
+function parseAssaySummary(data) {
+    const columns = data.Table?.Columns?.Column ?? [];
+    const rows = data.Table?.Row ?? [];
+    // Find column indices by heading
+    const headingIndex = new Map();
+    for (let i = 0; i < columns.length; i++) {
+        if (columns[i].Heading) {
+            headingIndex.set(columns[i].Heading, i);
+        }
+    }
+    const aidIdx = headingIndex.get("AID");
+    const nameIdx = headingIndex.get("AssayName");
+    const targetIdx = headingIndex.get("TargetName");
+    const outcomeIdx = headingIndex.get("ActivityOutcome");
+    const valueIdx = headingIndex.get("ActivityValue");
+    const results = [];
+    for (const row of rows) {
+        const cells = row.Cell ?? [];
+        const getCellStr = (idx) => {
+            if (idx === undefined || idx >= cells.length)
+                return null;
+            return cells[idx]?.sval ?? null;
+        };
+        const getCellNum = (idx) => {
+            if (idx === undefined || idx >= cells.length)
+                return null;
+            const cell = cells[idx];
+            if (cell?.fval !== undefined)
+                return cell.fval;
+            if (cell?.intval !== undefined)
+                return cell.intval;
+            return null;
+        };
+        results.push({
+            aid: getCellNum(aidIdx) ?? 0,
+            assayName: getCellStr(nameIdx),
+            targetName: getCellStr(targetIdx),
+            activityOutcome: getCellStr(outcomeIdx),
+            activityValue: getCellNum(valueIdx),
+        });
+    }
+    return results;
+}
+export const getPubchemAssaysTool = defineTool({
+    id: "get_pubchem_assays",
+    description: "Get bioassay screening summaries for a PubChem CID. " +
+        "Returns per-assay activity outcomes (Active/Inactive/Inconclusive), target names, " +
+        "and activity values. Covers HTS screening data beyond ChEMBL's curated bioactivity. " +
+        "Use activeOnly=true to filter for active results only.",
+    inputSchema: z.object({
+        cid: z.number().int().positive().describe("PubChem Compound ID (CID)"),
+        activeOnly: z.boolean().default(false).describe("If true, return only assays where the compound was active"),
+        limit: z.number().int().min(1).max(500).default(50).describe("Maximum number of assay records to return"),
+    }),
+    execute: async ({ cid, activeOnly = false, limit = 50 }) => {
+        const url = `${PUBCHEM_BASE}/compound/cid/${cid}/assaysummary/JSON`;
+        const res = await apiFetchValidated(url, PugAssaySummarySchema, { headers: HEADERS });
+        if (res.isErr()) {
+            // PubChem returns 404 when the CID has no assay data — expected.
+            if (res.error.type === "http_status" && res.error.status === 404)
+                return ok({ assays: [] });
+            throw new Error(describeApiError(res.error));
+        }
+        let assays = parseAssaySummary(res.value);
+        if (activeOnly) {
+            assays = assays.filter((a) => a.activityOutcome?.toLowerCase() === "active");
+        }
+        return ok({ assays: assays.slice(0, limit) });
+    },
+});

package/dist/tools/bio/get-pubchem-cross-refs.d.ts

@@ -0,0 +1,15 @@
+/**
+ * getPubchemCrossRefs tool — retrieve external database identifiers for a PubChem CID.
+ *
+ * Bridges PubChem compounds to ChEMBL, DrugBank, KEGG, PDB, and other registries.
+ */
+interface CrossRefEntry {
+    source: string;
+    id: string;
+}
+export declare const getPubchemCrossRefsTool: import("../define-tool.js").Tool<{
+    cid: number;
+}, {
+    crossRefs: CrossRefEntry[];
+}>;
+export {};

package/dist/tools/bio/get-pubchem-cross-refs.js

@@ -0,0 +1,68 @@
+/**
+ * getPubchemCrossRefs tool — retrieve external database identifiers for a PubChem CID.
+ *
+ * Bridges PubChem compounds to ChEMBL, DrugBank, KEGG, PDB, and other registries.
+ */
+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";
+// The PUG-REST xrefs wire shape, validated at the fetch boundary: one
+// `Information` entry per CID with parallel `RegistryID[]` / `SourceName[]`
+// arrays. Every field is optional — PubChem omits absent values.
+const PubChemXrefResponseSchema = z.object({
+    InformationList: z
+        .object({
+        Information: z
+            .array(z.object({
+            CID: z.number().optional(),
+            RegistryID: z.array(z.string()).optional(),
+            SourceName: z.array(z.string()).optional(),
+        }))
+            .optional(),
+    })
+        .optional(),
+});
+function mapCrossRef(raw) {
+    return {
+        source: raw.SourceName ?? "Unknown",
+        id: raw.RegistryID ?? "",
+    };
+}
+export const getPubchemCrossRefsTool = defineTool({
+    id: "get_pubchem_cross_refs",
+    description: "Get external database cross-references for a PubChem CID. " +
+        "Returns linked identifiers from ChEMBL, DrugBank, KEGG, PDB, and other registries. " +
+        "Use this to bridge PubChem compounds to other databases (e.g., get ChEMBL ID to then " +
+        "query bioactivity via ChEMBL tools).",
+    inputSchema: z.object({
+        cid: z.number().int().positive().describe("PubChem Compound ID (CID)"),
+    }),
+    execute: async ({ cid }) => {
+        const url = `${PUBCHEM_BASE}/compound/cid/${cid}/xrefs/RegistryID,SourceName/JSON`;
+        const res = await apiFetchValidated(url, PubChemXrefResponseSchema, { headers: HEADERS });
+        if (res.isErr()) {
+            // PubChem returns 404 when the CID has no cross-references — expected.
+            if (res.error.type === "http_status" && res.error.status === 404)
+                return ok({ crossRefs: [] });
+            throw new Error(describeApiError(res.error));
+        }
+        // PUG-REST xrefs returns an InformationList with one entry per CID.
+        // Each entry has parallel RegistryID[] and SourceName[] arrays.
+        const info = res.value.InformationList?.Information?.[0];
+        if (!info?.RegistryID?.length) {
+            return ok({ crossRefs: [] });
+        }
+        const crossRefs = [];
+        const registryIds = info.RegistryID;
+        const sourceNames = info.SourceName ?? [];
+        for (let i = 0; i < registryIds.length; i++) {
+            crossRefs.push(mapCrossRef({
+                RegistryID: registryIds[i],
+                SourceName: sourceNames[i],
+            }));
+        }
+        return ok({ crossRefs });
+    },
+});

package/dist/tools/bio/get-target-safety.d.ts

@@ -0,0 +1,18 @@
+/**
+ * getTargetSafety — fetch known safety liabilities for a target from
+ * Open Targets.
+ */
+import { getTargetSafetyLiabilities } from "../lib/opentargets-client.js";
+type SafetyLiabilities = NonNullable<Awaited<ReturnType<typeof getTargetSafetyLiabilities>>>["safetyLiabilities"];
+type GetTargetSafetyOutput = {
+    found: false;
+    ensemblId: string;
+} | {
+    found: true;
+    targetSymbol: string;
+    safetyLiabilities: SafetyLiabilities;
+};
+export declare const getTargetSafetyTool: import("../define-tool.js").Tool<{
+    ensemblId: string;
+}, GetTargetSafetyOutput>;
+export {};

package/dist/tools/bio/get-target-safety.js

@@ -0,0 +1,26 @@
+/**
+ * getTargetSafety — fetch known safety liabilities for a target from
+ * Open Targets.
+ */
+import { ok } from "neverthrow";
+import { z } from "zod";
+import { defineTool } from "../define-tool.js";
+import { getTargetSafetyLiabilities } from "../lib/opentargets-client.js";
+export const getTargetSafetyTool = defineTool({
+    id: "get_target_safety",
+    description: "Get known safety liabilities for a target from Open Targets. Returns organ-specific toxicity signals, adverse events, and safety-related phenotypes linked to the target.",
+    inputSchema: z.object({
+        ensemblId: z.string().describe("Ensembl gene ID (e.g. ENSG00000141510)"),
+    }),
+    execute: async ({ ensemblId }) => {
+        const result = await getTargetSafetyLiabilities(ensemblId);
+        // "Target not found" is an expected outcome — a data variant, not an error.
+        if (!result)
+            return ok({ found: false, ensemblId });
+        return ok({
+            found: true,
+            targetSymbol: result.targetSymbol,
+            safetyLiabilities: result.safetyLiabilities,
+        });
+    },
+});

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

@@ -0,0 +1,41 @@
+/**
+ * Bio barrel — pure external-API bioinformatics & cheminformatics lookups.
+ *
+ * Leaf tools with no harness dependencies: each wraps an external data source
+ * (Ensembl, ChEMBL, PubChem, Open Targets, PubMed, EPA CompTox, …) behind a
+ * `defineTool`. Grouped here so the conversation agent imports one barrel
+ * rather than ~30 individual files.
+ */
+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 "./search-pharmgkb.js";
+export * from "./search-faers.js";
+export * from "./search-clinical-trials.js";
+export * from "./search-geo-datasets.js";
+export * from "./search-dgidb.js";
+export * from "./search-clinvar.js";
+export * from "./search-disgenet.js";
+export * from "./search-drugbank.js";
+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";

package/dist/tools/bio/index.js

@@ -0,0 +1,48 @@
+/**
+ * Bio barrel — pure external-API bioinformatics & cheminformatics lookups.
+ *
+ * Leaf tools with no harness dependencies: each wraps an external data source
+ * (Ensembl, ChEMBL, PubChem, Open Targets, PubMed, EPA CompTox, …) behind a
+ * `defineTool`. Grouped here so the conversation agent imports one barrel
+ * rather than ~30 individual files.
+ */
+// Genomics / pathways / ontology
+export * from "./search-gene.js";
+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";
+// 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";
+// PubChem
+export * from "./search-pubchem-compound.js";
+export * from "./get-pubchem-cross-refs.js";
+export * from "./get-pubchem-assays.js";
+// Translational medicine
+export * from "./search-opentargets.js";
+export * from "./get-target-safety.js";
+export * from "./search-pharmgkb.js";
+export * from "./search-faers.js";
+export * from "./search-clinical-trials.js";
+export * from "./search-geo-datasets.js";
+export * from "./search-dgidb.js";
+export * from "./search-clinvar.js";
+export * from "./search-disgenet.js";
+export * from "./search-drugbank.js";
+export * from "./search-gwas-catalog.js";
+// Preclinical
+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";

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

@@ -0,0 +1,31 @@
+import type { Tool } from "../define-tool.js";
+/**
+ * API keys for the external bio/chem data sources. Threaded from the
+ * composition root to every place that assembles bio tools (conversation
+ * agent, sandbox agents, literature reviewer, analogy reporter). Each key
+ * may be empty when its source is unconfigured — the tool surfaces the
+ * resulting auth failure as a normal tool error.
+ */
+export interface BioToolKeys {
+    readonly drugbank: string;
+    readonly disgenet: string;
+    readonly epaCcte: string;
+    readonly ncbi?: string;
+    readonly github?: string;
+}
+/** The NCBI-backed literature tools, built from the shared key slice. */
+export declare function createNcbiTools(keys: BioToolKeys): {
+    searchPubMed: Tool;
+    getArticleDetails: Tool;
+    getArticleFullText: Tool;
+    searchClinvar: Tool;
+};
+/** The DrugBank / DisGeNET / EPA CompTox tools, built from the key slice. */
+export declare function createChemDbTools(keys: BioToolKeys): {
+    searchDrugbank: Tool;
+    searchDisgenet: Tool;
+    searchToxcast: Tool;
+    searchCtxHazard: Tool;
+    searchCtxChemical: Tool;
+    searchCtxExposure: Tool;
+};

package/dist/tools/bio/keys.js

@@ -0,0 +1,30 @@
+import { createSearchPubMedTool } from "./search-pubmed.js";
+import { createGetArticleDetailsTool } from "./get-article-details.js";
+import { createGetArticleFullTextTool } from "./get-article-full-text.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. */
+export function createNcbiTools(keys) {
+    return {
+        searchPubMed: createSearchPubMedTool({ ncbiApiKey: keys.ncbi }),
+        getArticleDetails: createGetArticleDetailsTool({ ncbiApiKey: keys.ncbi }),
+        getArticleFullText: createGetArticleFullTextTool({ ncbiApiKey: keys.ncbi }),
+        searchClinvar: createSearchClinvarTool({ ncbiApiKey: keys.ncbi }),
+    };
+}
+/** The DrugBank / DisGeNET / EPA CompTox tools, built from the key slice. */
+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 }),
+    };
+}

package/dist/tools/bio/lookup-go-term.d.ts

@@ -0,0 +1,31 @@
+/**
+ * lookupGoTerm — look up Gene Ontology terms via the QuickGO API (EBI).
+ *
+ * Supports direct ID lookup, keyword search, and gene annotation retrieval.
+ * Multiple modes can be combined in a single call.
+ */
+interface GoTerm {
+    id: string;
+    name: string;
+    definition?: string;
+    aspect?: string;
+}
+interface GoAnnotation {
+    geneProductId: string;
+    goId: string;
+    goName: string;
+    aspect?: string;
+    evidenceCode?: string;
+    qualifier?: string;
+}
+export declare const lookupGoTermTool: import("../define-tool.js").Tool<{
+    limit: number;
+    goId?: string | undefined;
+    query?: string | undefined;
+    geneProductId?: string | undefined;
+    taxonId?: number | undefined;
+}, {
+    terms: GoTerm[] | undefined;
+    annotations: GoAnnotation[] | undefined;
+}>;
+export {};