@inflexa-ai/harness 0.12.0 → 0.14.0

package/dist/tools/bio/lookup-go-term.js

@@ -1,116 +0,0 @@
-/**
- * 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.
- */
-import { ok } from "neverthrow";
-import { z } from "zod";
-import { defineTool } from "../define-tool.js";
-import { apiFetchValidated, describeApiError } from "../lib/api-utils.js";
-const QUICKGO_BASE = "https://www.ebi.ac.uk/QuickGO/services";
-const HEADERS = { Accept: "application/json" };
-// QuickGO term response, validated at the fetch boundary. The `.transform`
-// carries the (context-free) rename from the raw wire fields to the `GoTerm[]`
-// we return, so parsing IS both the validation and the normalization — there
-// is no separate raw interface or mapper to keep in sync.
-const GoTermResponseSchema = z
-    .object({
-    results: z
-        .array(z.object({
-        id: z.string().optional(),
-        name: z.string().optional(),
-        definition: z.object({ text: z.string().optional() }).nullable().optional(),
-        aspect: z.string().optional(),
-    }))
-        .optional(),
-})
-    .transform((res) => (res.results ?? []).map((t) => ({
-    id: t.id ?? "",
-    name: t.name ?? "",
-    definition: t.definition?.text ?? undefined,
-    aspect: t.aspect ?? undefined,
-})));
-const GoAnnotationResponseSchema = z
-    .object({
-    results: z
-        .array(z.object({
-        geneProductId: z.string().optional(),
-        goId: z.string().optional(),
-        goName: z.string().optional(),
-        goAspect: z.string().optional(),
-        goEvidence: z.string().optional(),
-        qualifier: z.string().optional(),
-    }))
-        .optional(),
-})
-    .transform((res) => (res.results ?? []).map((a) => ({
-    geneProductId: a.geneProductId ?? "",
-    goId: a.goId ?? "",
-    goName: a.goName ?? "",
-    aspect: a.goAspect ?? undefined,
-    evidenceCode: a.goEvidence ?? undefined,
-    qualifier: a.qualifier ?? undefined,
-})));
-export const lookupGoTermTool = defineTool({
-    id: "lookup_go_term",
-    description: "Look up Gene Ontology terms from QuickGO (EBI). " +
-        "Can look up a term by GO ID, search by keyword, or retrieve GO annotations " +
-        "for a specific gene/protein. At least one of goId, query, or geneProductId must be provided.",
-    inputSchema: z
-        .object({
-        goId: z
-            .string()
-            .regex(/^GO:\d{7}$/)
-            .optional()
-            .describe("Specific GO term ID (e.g. 'GO:0008150')"),
-        query: z.string().optional().describe("Free-text search for GO terms (e.g. 'apoptotic process')"),
-        limit: z.number().int().min(1).max(100).default(10).describe("Maximum number of results per query type"),
-        geneProductId: z.string().optional().describe("UniProt ID to get annotations for (e.g. 'P04637')"),
-        taxonId: z.number().int().optional().describe("NCBI Taxon ID to filter annotations (9606 = human, 10090 = mouse)"),
-    })
-        .refine((d) => d.goId || d.query || d.geneProductId, {
-        message: "At least one of goId, query, or geneProductId is required",
-    }),
-    execute: async ({ goId, query, limit, geneProductId, taxonId }) => {
-        const tasks = [];
-        let terms;
-        let annotations;
-        if (goId) {
-            tasks.push((async () => {
-                const res = await apiFetchValidated(`${QUICKGO_BASE}/ontology/go/terms/${encodeURIComponent(goId)}`, GoTermResponseSchema, {
-                    headers: HEADERS,
-                });
-                if (res.isErr())
-                    throw new Error(`GO lookup: ${describeApiError(res.error)}`);
-                terms = res.value;
-            })());
-        }
-        if (query) {
-            tasks.push((async () => {
-                const params = new URLSearchParams({ query, limit: String(limit) });
-                const res = await apiFetchValidated(`${QUICKGO_BASE}/ontology/go/search?${params}`, GoTermResponseSchema, { headers: HEADERS });
-                if (res.isErr())
-                    throw new Error(`GO search: ${describeApiError(res.error)}`);
-                const searchTerms = res.value;
-                terms = terms ? [...terms, ...searchTerms] : searchTerms;
-            })());
-        }
-        if (geneProductId) {
-            tasks.push((async () => {
-                const params = new URLSearchParams({
-                    geneProductId,
-                    limit: String(limit),
-                });
-                if (taxonId)
-                    params.set("taxonId", String(taxonId));
-                const res = await apiFetchValidated(`${QUICKGO_BASE}/annotation/search?${params}`, GoAnnotationResponseSchema, { headers: HEADERS });
-                if (res.isErr())
-                    throw new Error(`Annotations: ${describeApiError(res.error)}`);
-                annotations = res.value;
-            })());
-        }
-        await Promise.all(tasks);
-        return ok({ terms, annotations });
-    },
-});

package/dist/tools/bio/search-bgee-expression.d.ts

@@ -1,10 +0,0 @@
-/**
- * searchBgeeExpression tool — cross-species baseline gene expression.
- */
-import { SUPPORTED_SPECIES, bucketRank, parseExpressionResponse } from "../lib/bgee-client.js";
-export type { SupportedSpecies } from "../lib/bgee-client.js";
-export { SUPPORTED_SPECIES, bucketRank, parseExpressionResponse };
-export declare const searchBgeeExpressionTool: import("../define-tool.js").Tool<{
-    geneSymbol: string;
-    species: ("homo_sapiens" | "mus_musculus" | "rattus_norvegicus" | "canis_lupus_familiaris" | "macaca_mulatta")[];
-}, import("../lib/bgee-client.js").MultiSpeciesExpression>;

package/dist/tools/bio/search-bgee-expression.js

@@ -1,30 +0,0 @@
-/**
- * searchBgeeExpression tool — cross-species baseline gene expression.
- */
-import { ok } from "neverthrow";
-import { z } from "zod";
-import { defineTool } from "../define-tool.js";
-import { SUPPORTED_SPECIES, bucketRank, getMultiSpeciesExpression, parseExpressionResponse } from "../lib/bgee-client.js";
-export { SUPPORTED_SPECIES, bucketRank, parseExpressionResponse };
-export const searchBgeeExpressionTool = defineTool({
-    id: "search_bgee_expression",
-    description: "Get BASELINE (healthy, untreated) gene expression across species from Bgee — use it to judge tissue-of-action ('where is this target expressed?') and model-organism " +
-        "suitability ('is the mouse a fair surrogate for this gene?'). " +
-        "NOT for differential expression between conditions — that is the analysis pipeline's job, never this tool. " +
-        "Takes a human gene symbol and resolves the per-species orthologs itself, returning a per-species tissue table: each tissue carries an expression score, a gold/silver confidence, " +
-        "an expressed / not-expressed state, and a bucketed rank (absent | low | medium | high). Species with no ortholog are listed in notFound. " +
-        "Sparse output is valid no-data: dog and macaque coverage is thin, and a null humanEnsemblId means the symbol did not resolve. Do NOT retry on empty output.",
-    inputSchema: z.object({
-        geneSymbol: z
-            .string()
-            .min(1)
-            .describe("HUMAN gene symbol, e.g. 'BRCA1' — one gene per call. Ensembl IDs and non-human symbols are not accepted; the human symbol is resolved to an ENSG and orthologs are looked up per species."),
-        species: z
-            .array(z.enum(SUPPORTED_SPECIES))
-            .min(1)
-            .default([...SUPPORTED_SPECIES])
-            .describe("Species to fetch, any subset of: homo_sapiens, mus_musculus, rattus_norvegicus, canis_lupus_familiaris, macaca_mulatta. " +
-            "Defaults to all five — narrow it only when the cross-species comparison is not needed."),
-    }),
-    execute: async ({ geneSymbol, species }) => ok(await getMultiSpeciesExpression(geneSymbol, species)),
-});

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

@@ -1,13 +0,0 @@
-/**
- * searchClinvar — search NCBI ClinVar for clinical significance of variants.
- */
-export declare function createSearchClinvarTool(deps: {
-    ncbiApiKey?: string;
-}): import("../define-tool.js").Tool<{
-    query: string;
-    limit: number;
-    clinicalSignificance?: "pathogenic" | "likely-pathogenic" | "benign" | "likely-benign" | "uncertain" | undefined;
-}, {
-    totalFound: number;
-    variants: import("../lib/clinvar-client.js").ClinvarVariant[];
-}>;

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

@@ -1,28 +0,0 @@
-/**
- * searchClinvar — search NCBI ClinVar for clinical significance of variants.
- */
-import { ok } from "neverthrow";
-import { z } from "zod";
-import { defineTool } from "../define-tool.js";
-import { searchClinvar } from "../lib/clinvar-client.js";
-export function createSearchClinvarTool(deps) {
-    return defineTool({
-        id: "search_clinvar",
-        description: "Search NCBI ClinVar for clinical significance of genetic variants. Returns pathogenicity classifications, associated conditions, and review status. Use to assess whether variants identified in omics data have known clinical significance.",
-        inputSchema: z.object({
-            query: z.string().describe("Gene symbol (e.g. BRCA1), variant (e.g. NM_007294.4:c.5266dupC), dbSNP rsID (e.g. rs80357906), or condition name"),
-            clinicalSignificance: z
-                .enum(["pathogenic", "likely-pathogenic", "benign", "likely-benign", "uncertain"])
-                .optional()
-                .describe("Filter by clinical significance"),
-            limit: z.number().int().min(1).max(100).default(20).describe("Max results to return"),
-        }),
-        execute: async ({ query, clinicalSignificance, limit = 20 }) => {
-            const { totalFound, variants } = await searchClinvar(deps.ncbiApiKey, query, {
-                clinicalSignificance,
-                limit,
-            });
-            return ok({ totalFound, variants });
-        },
-    });
-}

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

@@ -1,53 +0,0 @@
-/**
- * searchDgidb tool — query drug-gene interactions via DGIdb GraphQL.
- *
- * DGIdb aggregates interactions from 30+ sources (ChEMBL, DrugBank, TTD,
- * PharmGKB, GuideToPharmacology, CIViC, etc.). Free, no API key required.
- *
- * Two directions:
- *   - searchType="gene": input HUGO symbols, returns drugs interacting with each.
- *   - searchType="drug": input drug names/concept IDs, returns genes each acts on.
- */
-import type { Logger } from "../../lib/logger.js";
-interface Interaction {
-    geneName: string;
-    drugName: string;
-    drugConceptId?: string;
-    interactionTypes: {
-        type: string;
-        directionality?: string;
-    }[];
-    interactionScore?: number;
-    sourceCount: number;
-    sources: string[];
-    publicationCount: number;
-    pmids: string[];
-    attributes: {
-        name: string;
-        value: string;
-    }[];
-}
-/**
- * A factory rather than a bare const (unlike its bio-leaf siblings) because it
- * logs: DGIdb answers GraphQL partial errors alongside usable data, and an
- * operator debugging odd interaction results needs to see them. `ToolContext`
- * carries no deps by design, so a tool that logs is dep-bearing — the same
- * reason `createSearchClinvarTool` takes its key that way.
- */
-export declare function createSearchDgidbTool(deps?: {
-    readonly logger?: Logger;
-}): import("../define-tool.js").Tool<{
-    query: string | string[];
-    searchType: "drug" | "gene";
-    minSources: number;
-    limit: number;
-    interactionTypes?: string[] | undefined;
-    sources?: string[] | undefined;
-}, {
-    results: {
-        input: string;
-        found: boolean;
-        interactions: Interaction[];
-    }[];
-}>;
-export {};

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

@@ -1,213 +0,0 @@
-/**
- * searchDgidb tool — query drug-gene interactions via DGIdb GraphQL.
- *
- * DGIdb aggregates interactions from 30+ sources (ChEMBL, DrugBank, TTD,
- * PharmGKB, GuideToPharmacology, CIViC, etc.). Free, no API key required.
- *
- * Two directions:
- *   - searchType="gene": input HUGO symbols, returns drugs interacting with each.
- *   - searchType="drug": input drug names/concept IDs, returns genes each acts on.
- */
-import { ok } from "neverthrow";
-import { z } from "zod";
-import { defineTool } from "../define-tool.js";
-import { createNoopLogger } from "../../lib/console-logger.js";
-import { apiFetchValidated, describeApiError } from "../lib/api-utils.js";
-const DGIDB_GRAPHQL_URL = "https://dgidb.org/api/graphql";
-const GENE_INTERACTIONS_QUERY = `query($genes: [String!]!) {
-  genes(names: $genes) {
-    nodes {
-      name
-      interactions {
-        interactionScore
-        interactionTypes { type directionality }
-        drug { name conceptId }
-        interactionAttributes { name value }
-        publications { pmid }
-        sources { sourceDbName }
-      }
-    }
-  }
-}`;
-const DRUG_INTERACTIONS_QUERY = `query($drugs: [String!]!) {
-  drugs(names: $drugs) {
-    nodes {
-      name
-      conceptId
-      interactions {
-        interactionScore
-        interactionTypes { type directionality }
-        gene { name }
-        interactionAttributes { name value }
-        publications { pmid }
-        sources { sourceDbName }
-      }
-    }
-  }
-}`;
-// Shape of the DGIdb GraphQL payload as it arrives on the wire. Validated at
-// the fetch boundary; `mapInteraction` normalizes each record into the
-// `Interaction` we return. Most fields are optional/nullable to match GraphQL's
-// per-field nullability — but `RawNode.name` is required because we key the
-// node map on `name.toLowerCase()`; a node missing it is a contract break we
-// surface as an `invalid_response` error rather than a runtime TypeError.
-const RawInteractionSchema = z.object({
-    interactionScore: z.number().nullable().optional(),
-    interactionTypes: z.array(z.object({ type: z.string().optional(), directionality: z.string().nullable().optional() })).optional(),
-    drug: z.object({ name: z.string().optional(), conceptId: z.string().nullable().optional() }).nullable().optional(),
-    gene: z.object({ name: z.string().optional() }).nullable().optional(),
-    interactionAttributes: z.array(z.object({ name: z.string().optional(), value: z.string().optional() })).optional(),
-    publications: z.array(z.object({ pmid: z.union([z.string(), z.number()]).optional() })).optional(),
-    sources: z.array(z.object({ sourceDbName: z.string().optional() })).optional(),
-});
-const RawNodeSchema = z.object({
-    name: z.string(),
-    conceptId: z.string().nullable().optional(),
-    interactions: z.array(RawInteractionSchema).optional(),
-});
-const DgidbResponseSchema = z.object({
-    data: z
-        .object({
-        genes: z.object({ nodes: z.array(RawNodeSchema).optional() }).optional(),
-        drugs: z.object({ nodes: z.array(RawNodeSchema).optional() }).optional(),
-    })
-        .optional(),
-    errors: z.array(z.object({ message: z.string().optional() })).optional(),
-});
-function mapInteraction(raw, perspective, inputSide) {
-    const sources = (raw.sources ?? []).map((s) => s.sourceDbName ?? "").filter(Boolean);
-    const pmids = (raw.publications ?? []).map((p) => (p.pmid != null ? String(p.pmid) : "")).filter(Boolean);
-    const types = (raw.interactionTypes ?? []).map((t) => ({
-        type: t.type ?? "",
-        ...(t.directionality ? { directionality: t.directionality } : {}),
-    }));
-    const attributes = (raw.interactionAttributes ?? []).slice(0, 20).map((a) => ({
-        name: a.name ?? "",
-        value: (a.value ?? "").slice(0, 200),
-    }));
-    const geneName = perspective === "gene" ? (inputSide.geneName ?? "") : (raw.gene?.name ?? "");
-    const drugName = perspective === "drug" ? (inputSide.drugName ?? "") : (raw.drug?.name ?? "");
-    const drugConceptId = perspective === "drug" ? inputSide.drugConceptId : (raw.drug?.conceptId ?? undefined);
-    return {
-        geneName,
-        drugName,
-        ...(drugConceptId ? { drugConceptId } : {}),
-        interactionTypes: types,
-        ...(raw.interactionScore != null ? { interactionScore: raw.interactionScore } : {}),
-        sourceCount: sources.length,
-        sources,
-        publicationCount: pmids.length,
-        pmids: pmids.slice(0, 10),
-        attributes,
-    };
-}
-function applyFilters(interactions, filters) {
-    let out = interactions;
-    if (filters.interactionTypes?.length) {
-        const needles = filters.interactionTypes.map((s) => s.toLowerCase());
-        out = out.filter((i) => i.interactionTypes.some((t) => needles.some((n) => t.type.toLowerCase().includes(n))));
-    }
-    if (filters.sources?.length) {
-        const needles = filters.sources.map((s) => s.toLowerCase());
-        out = out.filter((i) => i.sources.some((s) => needles.some((n) => s.toLowerCase().includes(n))));
-    }
-    if (filters.minSources > 0) {
-        out = out.filter((i) => i.sourceCount >= filters.minSources);
-    }
-    return out;
-}
-/**
- * A factory rather than a bare const (unlike its bio-leaf siblings) because it
- * logs: DGIdb answers GraphQL partial errors alongside usable data, and an
- * operator debugging odd interaction results needs to see them. `ToolContext`
- * carries no deps by design, so a tool that logs is dep-bearing — the same
- * reason `createSearchClinvarTool` takes its key that way.
- */
-export function createSearchDgidbTool(deps = {}) {
-    const logger = (deps.logger ?? createNoopLogger()).named("search_dgidb");
-    return defineTool({
-        id: "search_dgidb",
-        description: "Query the Drug-Gene Interaction Database (DGIdb) for drug-gene interactions. " +
-            "DGIdb aggregates 30+ sources (ChEMBL, DrugBank, TTD, PharmGKB, GuideToPharmacology, CIViC, etc.) " +
-            "and returns source counts as a confidence signal. " +
-            "searchType='gene' returns drugs interacting with input HUGO gene symbols (most common: 'what drugs hit my gene set?'). " +
-            "searchType='drug' returns the genes each input drug is known to act on. " +
-            "Free, no API key required. Sorted by source count desc.",
-        inputSchema: z.object({
-            query: z
-                .union([z.string(), z.array(z.string()).max(50)])
-                .describe("Single identifier or list of up to 50. For searchType='gene': HUGO symbols. For searchType='drug': drug names or DGIdb concept IDs."),
-            searchType: z.enum(["gene", "drug"]).default("gene"),
-            interactionTypes: z
-                .array(z.string())
-                .optional()
-                .describe("Case-insensitive substring filter on interaction type. e.g. ['inhibitor', 'antagonist']"),
-            sources: z.array(z.string()).optional().describe("Restrict to interactions from these source DBs (case-insensitive substring)."),
-            minSources: z.number().int().min(1).default(1).describe("Drop interactions supported by fewer than this many sources."),
-            limit: z.number().int().min(1).max(200).default(50).describe("Max interactions per input gene/drug after filtering."),
-        }),
-        execute: async ({ query, searchType = "gene", interactionTypes, sources, minSources = 1, limit = 50 }) => {
-            const inputs = typeof query === "string" ? [query] : query;
-            if (inputs.length === 0 || inputs.every((s) => !s.trim())) {
-                throw new Error("query must contain at least one identifier");
-            }
-            const isGene = searchType === "gene";
-            const variableName = isGene ? "genes" : "drugs";
-            const queryString = isGene ? GENE_INTERACTIONS_QUERY : DRUG_INTERACTIONS_QUERY;
-            const res = await apiFetchValidated(DGIDB_GRAPHQL_URL, DgidbResponseSchema, {
-                method: "POST",
-                headers: { "Content-Type": "application/json" },
-                body: JSON.stringify({
-                    query: queryString,
-                    variables: { [variableName]: inputs },
-                }),
-            });
-            if (res.isErr())
-                throw new Error(describeApiError(res.error));
-            const body = res.value;
-            if (!body || !body.data)
-                throw new Error("DGIdb returned no data");
-            if (body.errors?.length) {
-                logger.warn("dgidb partial errors alongside data", { errors: body.errors.slice(0, 3) });
-            }
-            const nodes = (isGene ? body.data.genes?.nodes : body.data.drugs?.nodes) ?? [];
-            const nodeMap = new Map();
-            for (const node of nodes) {
-                nodeMap.set(node.name.toLowerCase(), node);
-                if (!isGene && node.conceptId) {
-                    nodeMap.set(node.conceptId.toLowerCase(), node);
-                }
-            }
-            const results = inputs.map((input) => {
-                const node = nodeMap.get(input.toLowerCase());
-                if (!node) {
-                    return { input, found: false, interactions: [] };
-                }
-                const inputSide = isGene
-                    ? { geneName: node.name }
-                    : {
-                        drugName: node.name,
-                        drugConceptId: node.conceptId ?? undefined,
-                    };
-                const mapped = (node.interactions ?? []).map((raw) => mapInteraction(raw, searchType, inputSide));
-                const filtered = applyFilters(mapped, {
-                    interactionTypes,
-                    sources,
-                    minSources,
-                });
-                const sorted = filtered.sort((a, b) => {
-                    if (b.sourceCount !== a.sourceCount) {
-                        return b.sourceCount - a.sourceCount;
-                    }
-                    return (b.interactionScore ?? 0) - (a.interactionScore ?? 0);
-                });
-                return {
-                    input,
-                    found: true,
-                    interactions: sorted.slice(0, limit),
-                };
-            });
-            return ok({ results });
-        },
-    });
-}

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

@@ -1,30 +0,0 @@
-/**
- * searchDisgenet — search DisGeNET for gene-disease associations (GDAs).
- *
- * Requires `DISGENET_API_KEY`. Without the key, `getDisgenetHeaders` throws
- * on first call; the harness surfaces that as a tool `is_error` envelope.
- */
-export declare function createSearchDisgenetTool(deps: {
-    apiKey: string;
-}): import("../define-tool.js").Tool<{
-    query: string;
-    searchType: "gene" | "disease";
-    minScore: number;
-    source: "ALL" | "CURATED" | "ANIMAL_MODELS" | "BEFREE";
-    limit: number;
-}, {
-    associations: {
-        geneSymbol: string;
-        geneName: string;
-        geneId: number;
-        diseaseName: string;
-        diseaseId: string;
-        diseaseType: string;
-        score: number;
-        evidenceIndex: number;
-        yearInitial: number | null;
-        yearFinal: number | null;
-        nPmids: number;
-        source: string;
-    }[];
-}>;

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

@@ -1,84 +0,0 @@
-/**
- * searchDisgenet — search DisGeNET for gene-disease associations (GDAs).
- *
- * Requires `DISGENET_API_KEY`. Without the key, `getDisgenetHeaders` throws
- * on first call; the harness surfaces that as a tool `is_error` envelope.
- */
-import { ok } from "neverthrow";
-import { z } from "zod";
-import { defineTool } from "../define-tool.js";
-import { apiFetchValidated, describeApiError } from "../lib/api-utils.js";
-import { DISGENET_BASE, getDisgenetHeaders } from "../lib/disgenet-config.js";
-// A single schema that both validates and normalizes one DisGeNET GDA record:
-// the `.object(...)` half is the snake_case wire shape (every field optional —
-// the API omits absent values), the `.transform(...)` half maps it to the
-// camelCase `Gda` we return. Parsing IS the validation (`apiFetchValidated`
-// runs it over the JSON), and because the transform rides on the schema,
-// `z.infer` below is the OUTPUT type — no separate raw interface or mapper.
-const GdaSchema = z
-    .object({
-    gene_symbol: z.string().nullable().optional(),
-    gene_name: z.string().nullable().optional(),
-    geneid: z.number().nullable().optional(),
-    disease_name: z.string().nullable().optional(),
-    diseaseid: z.string().nullable().optional(),
-    disease_type: z.string().nullable().optional(),
-    score: z.number().nullable().optional(),
-    ei: z.number().nullable().optional(),
-    year_initial: z.number().nullable().optional(),
-    year_final: z.number().nullable().optional(),
-    pmid_count: z.number().nullable().optional(),
-    source: z.string().nullable().optional(),
-})
-    .transform((gda) => ({
-    geneSymbol: gda.gene_symbol ?? "",
-    geneName: gda.gene_name ?? "",
-    geneId: gda.geneid ?? 0,
-    diseaseName: gda.disease_name ?? "",
-    diseaseId: gda.diseaseid ?? "",
-    diseaseType: gda.disease_type ?? "",
-    score: gda.score ?? 0,
-    evidenceIndex: gda.ei ?? 0,
-    yearInitial: gda.year_initial ?? null,
-    yearFinal: gda.year_final ?? null,
-    nPmids: gda.pmid_count ?? 0,
-    source: gda.source ?? "",
-}));
-const GdaListSchema = z.array(GdaSchema);
-export function createSearchDisgenetTool(deps) {
-    return defineTool({
-        id: "search_disgenet",
-        description: "Search DisGeNET for gene-disease associations (GDAs). Returns association scores, " +
-            "evidence counts, and disease classifications. Requires DISGENET_API_KEY. " +
-            "Use for target validation — high-scoring GDAs provide genetic support for a " +
-            "therapeutic target's disease relevance.",
-        inputSchema: z.object({
-            query: z.string().describe("Gene symbol (e.g. TP53), Entrez gene ID (e.g. 7157), or disease name/UMLS CUI (e.g. C0006142 for breast cancer)"),
-            searchType: z.enum(["gene", "disease"]).describe("'gene' to find diseases for a gene, 'disease' to find genes for a disease"),
-            minScore: z.number().min(0).max(1).default(0.1).describe("Minimum GDA score (0–1). Higher = stronger evidence"),
-            source: z.enum(["ALL", "CURATED", "ANIMAL_MODELS", "BEFREE"]).default("ALL").describe("Evidence source filter"),
-            limit: z.number().int().min(1).max(100).default(25).describe("Max results to return"),
-        }),
-        execute: async ({ query, searchType, minScore = 0.1, source = "ALL", limit = 25 }) => {
-            const headers = getDisgenetHeaders(deps.apiKey);
-            let url;
-            if (searchType === "gene") {
-                const isNumeric = /^\d+$/.test(query);
-                const param = isNumeric ? `gene/${query}` : `gene/${encodeURIComponent(query)}`;
-                url = `${DISGENET_BASE}/gda/${param}?min_score=${minScore}&limit=${limit}`;
-            }
-            else {
-                url = `${DISGENET_BASE}/gda/disease/${encodeURIComponent(query)}?min_score=${minScore}&limit=${limit}`;
-            }
-            if (source !== "ALL") {
-                url += `&source=${source}`;
-            }
-            const res = await apiFetchValidated(url, GdaListSchema, { headers });
-            if (res.isErr())
-                throw new Error(describeApiError(res.error));
-            // Already validated + normalized to camelCase by GdaSchema's transform.
-            const associations = res.value;
-            return ok({ associations });
-        },
-    });
-}

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

@@ -1,38 +0,0 @@
-/**
- * searchDrugbank — search DrugBank for drug records and target-driven lookups.
- *
- * Requires `DRUGBANK_API_KEY`. Without the key, `getDrugbankHeaders` throws
- * on first call; the harness surfaces that as a tool `is_error` envelope.
- */
-export declare function createSearchDrugbankTool(deps: {
-    apiKey: string;
-}): import("../define-tool.js").Tool<{
-    query: string;
-    searchType: "target" | "drug";
-    limit: number;
-}, {
-    drugs: {
-        drugbankId: string;
-        name: string;
-        description: string;
-        type: string;
-        groups: string[];
-        categories: string[];
-        indication: string;
-        pharmacodynamics: string;
-        mechanismOfAction: string;
-        toxicity: string;
-        halfLife: string;
-        targets: {
-            name: string;
-            geneSymbol: string;
-            actions: string[];
-            knownAction: string;
-        }[];
-        interactions: {
-            drugbankId: string;
-            name: string;
-            description: string;
-        }[];
-    }[];
-}>;