@inflexa-ai/harness 0.13.0 → 0.14.0

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

@@ -0,0 +1,59 @@
+/**
+ * targetSafety — target-level, mechanism-based safety liability from the two
+ * sources that carry it: the curated secondary-pharmacology panel that ships
+ * with the harness, and Open Targets' curated liabilities.
+ *
+ * These were `check_safety_panel` and `opentargets({action:'safety'})`, and the
+ * panel tool's own description instructed calling them together — a pairing
+ * every caller had to remember, expressed in prose that had already gone stale
+ * (it named two tools that no longer exist). Both are keyed on the same target
+ * and answer the same question, so the pairing belongs in the tool.
+ *
+ * Identifier resolution is the tool's job, not the caller's: Open Targets
+ * accepts ONLY an Ensembl gene id, and it is taken from the panel entry when
+ * there is one and resolved from the gene symbol when there is not.
+ */
+import { type SafetyTarget } from "../../data/safety-panel-schema.js";
+import { type SafetyLiability } from "../lib/opentargets-client.js";
+declare const SOURCES: readonly ["panel", "opentargets"];
+type Source = (typeof SOURCES)[number];
+type ConcreteType = "chembl_id" | "gene_symbol" | "uniprot" | "ensembl_id";
+interface TargetRow {
+    input: string;
+    identifierType: ConcreteType;
+    /** The Ensembl id Open Targets was queried with, when one could be obtained. */
+    ensemblId?: string;
+    panelEntry?: SafetyTarget | null;
+    liabilities?: SafetyLiability[];
+    /** Liabilities Open Targets held before `liabilityLimit` trimmed them. */
+    liabilityCount?: number;
+    /** Why the Open Targets half is absent for this identifier, when it is. */
+    opentargetsNote?: string;
+}
+interface SourceOutcome {
+    source: Source;
+    status: "ok" | "no_data" | "unavailable";
+    /** Identifiers this source returned something for. */
+    matched: number;
+    detail?: string;
+}
+export declare const targetSafetyTool: import("../define-tool.js").Tool<{
+    identifiers: string[];
+    identifierType?: "auto" | "gene_symbol" | "uniprot" | "chembl_id" | "ensembl_id" | undefined;
+    sources?: ("opentargets" | "panel")[] | undefined;
+    filterOrgan?: "hematologic" | "metabolic" | "immune" | "hepatic" | "cns" | "renal" | "respiratory" | "cardiac" | "gi" | undefined;
+    minSeverity?: "high" | "medium" | "low" | undefined;
+    liabilityLimit?: number | undefined;
+}, {
+    perSource: SourceOutcome[];
+    summary: {
+        totalInput: number;
+        panelMatched: number;
+        bySeverity: Record<"high" | "medium" | "low", number>;
+        byOrgan: Record<string, number>;
+        openTargetsWithLiabilities: number;
+    };
+    targets: TargetRow[];
+    panelVersion: string;
+}>;
+export {};

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

@@ -0,0 +1,191 @@
+/**
+ * targetSafety — target-level, mechanism-based safety liability from the two
+ * sources that carry it: the curated secondary-pharmacology panel that ships
+ * with the harness, and Open Targets' curated liabilities.
+ *
+ * These were `check_safety_panel` and `opentargets({action:'safety'})`, and the
+ * panel tool's own description instructed calling them together — a pairing
+ * every caller had to remember, expressed in prose that had already gone stale
+ * (it named two tools that no longer exist). Both are keyed on the same target
+ * and answer the same question, so the pairing belongs in the tool.
+ *
+ * Identifier resolution is the tool's job, not the caller's: Open Targets
+ * accepts ONLY an Ensembl gene id, and it is taken from the panel entry when
+ * there is one and resolved from the gene symbol when there is not.
+ */
+import { ok } from "neverthrow";
+import { z } from "zod";
+import { CHEMBL_RE, ORGAN_SYSTEMS, SEVERITIES, SafetyPanelFileSchema, UNIPROT_RE, } from "../../data/safety-panel-schema.js";
+import panelData from "../../data/safety-panel.json" with { type: "json" };
+import { defineTool } from "../define-tool.js";
+import { resolveSymbolToEnsemblId } from "../lib/ensembl-client.js";
+import { getTargetSafetyLiabilities } from "../lib/opentargets-client.js";
+const PANEL = SafetyPanelFileSchema.parse(panelData);
+const BY_CHEMBL = new Map(PANEL.targets.map((t) => [t.chembl_id, t]));
+const BY_GENE = new Map(PANEL.targets.map((t) => [t.gene_symbol, t]));
+const BY_UNIPROT = new Map(PANEL.targets.map((t) => [t.uniprot, t]));
+const ENSG_RE = /^ENSG\d{11}$/;
+/** Ordered weakest → strongest so `minSeverity` can be a numeric floor. */
+const SEVERITY_ORDER = { low: 0, medium: 1, high: 2 };
+const SOURCES = ["panel", "opentargets"];
+/** Identifiers the panel can be swept for free; Open Targets costs a request each. */
+const MAX_PANEL_IDENTIFIERS = 200;
+const MAX_OPENTARGETS_IDENTIFIERS = 25;
+const DEFAULT_LIABILITY_LIMIT = 10;
+function detectType(id) {
+    if (CHEMBL_RE.test(id))
+        return "chembl_id";
+    if (ENSG_RE.test(id))
+        return "ensembl_id";
+    if (UNIPROT_RE.test(id))
+        return "uniprot";
+    return "gene_symbol";
+}
+function panelLookup(id, type) {
+    switch (type) {
+        case "chembl_id":
+            return BY_CHEMBL.get(id) ?? null;
+        case "gene_symbol":
+            return BY_GENE.get(id.toUpperCase()) ?? null;
+        case "uniprot":
+            return BY_UNIPROT.get(id) ?? null;
+        case "ensembl_id":
+            return PANEL.targets.find((t) => t.ensembl_gene_id === id) ?? null;
+    }
+}
+const inputSchema = z
+    .object({
+    identifiers: z
+        .array(z.string().min(1))
+        .min(1)
+        .max(MAX_PANEL_IDENTIFIERS)
+        .describe(`Target identifiers, 1–${MAX_PANEL_IDENTIFIERS} — gene symbols, ChEMBL target IDs, UniProt accessions, or Ensembl gene IDs, mixed ` +
+        `freely. Capped at ${MAX_OPENTARGETS_IDENTIFIERS} when source 'opentargets' is included, since that source costs a request per target.`),
+    identifierType: z
+        .enum(["chembl_id", "gene_symbol", "uniprot", "ensembl_id", "auto"])
+        .optional()
+        .describe("Default 'auto', detecting per input by shape (CHEMBL…, ENSG…, UniProt accession, else a gene symbol). Set it only to force one reading."),
+    sources: z
+        .array(z.enum(SOURCES))
+        .min(1)
+        .optional()
+        .describe("Default BOTH — the panel is a local lookup with no request cost, and they cover different ground. " +
+        "'panel': the curated secondary-pharmacology panel — a fast first-pass off-target screen giving organ system, severity and clinical " +
+        "consequence with references. Finite and hand-curated, so absence is NOT evidence of safety. " +
+        "'opentargets': curated target liabilities — event, affected biosamples, direction of effect, source. Needs an Ensembl gene id, taken " +
+        "from the panel entry or resolved from the symbol for you."),
+    filterOrgan: z.enum(ORGAN_SYSTEMS).optional().describe("'panel' only. Keep only matches in this organ system, when screening one liability class."),
+    minSeverity: z.enum(SEVERITIES).optional().describe("'panel' only. Drop matches below this severity; default 'low'. Use 'high' to triage a large set."),
+    liabilityLimit: z
+        .number()
+        .int()
+        .min(1)
+        .max(100)
+        .optional()
+        .describe(`'opentargets' only. Max liabilities per target (default ${DEFAULT_LIABILITY_LIMIT}, max 100); \`liabilityCount\` gives the true total.`),
+})
+    .refine((d) => (d.sources ?? [...SOURCES]).includes("opentargets") === false || d.identifiers.length <= MAX_OPENTARGETS_IDENTIFIERS, {
+    message: `identifiers is capped at ${MAX_OPENTARGETS_IDENTIFIERS} when source 'opentargets' is included (one request per target). ` +
+        `Either narrow the list, or pass sources: ['panel'] to sweep up to ${MAX_PANEL_IDENTIFIERS} against the local panel first and follow up on the hits.`,
+    path: ["identifiers"],
+});
+export const targetSafetyTool = defineTool({
+    id: "target_safety",
+    description: "TARGET-level, mechanism-based safety liability — the curated secondary-pharmacology panel and Open Targets' curated liabilities in one call. " +
+        "Judges what engaging a target is likely to do to an organ system, before any specific molecule exists. Identifiers may be gene symbols, ChEMBL " +
+        "target IDs, UniProt accessions or Ensembl gene IDs, mixed.\n" +
+        "This is the safety of the TARGET, not of a drug. For a marketed molecule's post-market adverse events use search_faers; for a chemical's " +
+        "toxicology use comptox; for what removing the gene does in vivo use gene_preclinical_profile.\n" +
+        "ABSENCE IS NOT SAFETY. The panel is finite and hand-curated, so no match means only 'not on the panel'; an empty Open Targets liability list " +
+        "means no CURATED liability, not that none exists. Both are valid no-data — do not retry. Read `perSource` and each row's `opentargetsNote`: a " +
+        "ChEMBL or UniProt identifier absent from the panel cannot be resolved to an Ensembl id, so its Open Targets half is skipped rather than empty.",
+    inputSchema,
+    execute: async ({ identifiers, identifierType, sources, filterOrgan, minSeverity, liabilityLimit }) => {
+        const selected = sources ?? [...SOURCES];
+        const wantPanel = selected.includes("panel");
+        const wantOpenTargets = selected.includes("opentargets");
+        const severityFloor = SEVERITY_ORDER[minSeverity ?? "low"];
+        const limit = liabilityLimit ?? DEFAULT_LIABILITY_LIMIT;
+        const rows = identifiers.map((input) => {
+            const type = identifierType && identifierType !== "auto" ? identifierType : detectType(input);
+            const row = { input, identifierType: type };
+            if (wantPanel) {
+                const entry = panelLookup(input, type);
+                const organMatches = !entry || !filterOrgan || entry.organ_system === filterOrgan;
+                const severityMatches = !entry || SEVERITY_ORDER[entry.severity] >= severityFloor;
+                row.panelEntry = entry && organMatches && severityMatches ? entry : null;
+            }
+            return row;
+        });
+        let opentargetsError;
+        if (wantOpenTargets) {
+            await Promise.all(rows.map(async (row) => {
+                // Open Targets takes an ENSG only. The panel entry carries one for
+                // free; a gene symbol can be resolved; a ChEMBL or UniProt id that
+                // is not on the panel cannot, and is skipped explicitly.
+                const panelEnsembl = panelLookup(row.input, row.identifierType)?.ensembl_gene_id;
+                let ensemblId = row.identifierType === "ensembl_id" ? row.input : (panelEnsembl ?? null);
+                if (!ensemblId && row.identifierType === "gene_symbol") {
+                    ensemblId = await resolveSymbolToEnsemblId(row.input);
+                    if (!ensemblId) {
+                        row.opentargetsNote = "gene symbol did not resolve to an Ensembl gene id";
+                        return;
+                    }
+                }
+                if (!ensemblId) {
+                    row.opentargetsNote = `no Ensembl gene id available for a ${row.identifierType} that is not on the panel`;
+                    return;
+                }
+                row.ensemblId = ensemblId;
+                try {
+                    const result = await getTargetSafetyLiabilities(ensemblId);
+                    if (!result) {
+                        row.opentargetsNote = "no Open Targets record for this Ensembl gene id";
+                        return;
+                    }
+                    row.liabilityCount = result.safetyLiabilities.length;
+                    row.liabilities = result.safetyLiabilities.slice(0, limit);
+                }
+                catch (error) {
+                    opentargetsError = error instanceof Error ? error.message : String(error);
+                    row.opentargetsNote = "Open Targets could not be reached";
+                }
+            }));
+        }
+        const bySeverity = { high: 0, medium: 0, low: 0 };
+        const byOrgan = {};
+        let panelMatched = 0;
+        for (const row of rows) {
+            if (!row.panelEntry)
+                continue;
+            panelMatched++;
+            bySeverity[row.panelEntry.severity]++;
+            byOrgan[row.panelEntry.organ_system] = (byOrgan[row.panelEntry.organ_system] ?? 0) + 1;
+        }
+        const withLiabilities = rows.filter((r) => (r.liabilities?.length ?? 0) > 0).length;
+        const perSource = [];
+        if (wantPanel) {
+            perSource.push({ source: "panel", status: panelMatched > 0 ? "ok" : "no_data", matched: panelMatched });
+        }
+        if (wantOpenTargets) {
+            perSource.push({
+                source: "opentargets",
+                status: opentargetsError ? "unavailable" : withLiabilities > 0 ? "ok" : "no_data",
+                matched: withLiabilities,
+                ...(opentargetsError ? { detail: opentargetsError } : {}),
+            });
+        }
+        return ok({
+            perSource,
+            summary: {
+                totalInput: identifiers.length,
+                panelMatched,
+                bySeverity,
+                byOrgan: byOrgan,
+                openTargetsWithLiabilities: withLiabilities,
+            },
+            targets: rows,
+            panelVersion: PANEL.panel_version,
+        });
+    },
+});

package/dist/tools/execute-analysis.d.ts

@@ -39,5 +39,6 @@ export declare function createExecuteAnalysisTool(deps: ExecuteAnalysisToolDeps)
     request?: string | undefined;
 }, {
     runId: string;
+    status: "in_progress";
 }>;
 export {};

package/dist/tools/execute-analysis.js

@@ -150,7 +150,7 @@ export function createExecuteAnalysisTool(deps) {
         description: "Launch analysis computation asynchronously. Use mode=plan with the planId only after the user approved that stored plan. " +
             "Use mode=adhoc with the user's exact targeted computational request when they explicitly asked to run/compute/test/compare it; " +
             "that explicit request is consent and needs no synthetic-plan approval. If computation is merely your suggestion, ask first. " +
-            "You never choose the sandbox specialist: ad hoc routing does that automatically. Returns runId; inspect results on a later turn.",
+            "You never choose the sandbox specialist: ad hoc routing does that automatically. Returns runId with status=in_progress; inspect results on a later turn.",
         inputSchema,
         execute: async (input, ctx) => {
             if (ctx.session.scope.kind !== "analysis")
@@ -174,7 +174,7 @@ export function createExecuteAnalysisTool(deps) {
                 const active = unwrapOrThrow(await queryActiveRun(deps.pool, analysisId, planId));
                 if (active) {
                     await emitRunCard(active.runId);
-                    return ok({ runId: active.runId });
+                    return ok({ runId: active.runId, status: "in_progress" });
                 }
             }
             else {
@@ -196,7 +196,7 @@ export function createExecuteAnalysisTool(deps) {
                         const active = unwrapOrThrow(await queryActiveRun(deps.pool, analysisId, planId));
                         if (active) {
                             await emitRunCard(active.runId);
-                            return ok({ runId: active.runId });
+                            return ok({ runId: active.runId, status: "in_progress" });
                         }
                     }
                     throw error;
@@ -212,7 +212,7 @@ export function createExecuteAnalysisTool(deps) {
                 }));
                 if (!reservation.inserted) {
                     await emitRunCard(reservation.row.runId);
-                    return ok({ runId: reservation.row.runId });
+                    return ok({ runId: reservation.row.runId, status: "in_progress" });
                 }
             }
             let authorization;
@@ -246,7 +246,7 @@ export function createExecuteAnalysisTool(deps) {
             }
             logger.info("analysis launched", { analysisId, runId, planId, mode: input.mode });
             await emitRunCard(runId);
-            return ok({ runId });
+            return ok({ runId, status: "in_progress" });
         },
     });
 }

package/dist/tools/lib/dgidb-client.d.ts

@@ -0,0 +1,49 @@
+/**
+ * Pure async client functions for the Drug-Gene Interaction Database (DGIdb)
+ * GraphQL API. Free, no key required.
+ *
+ * DGIdb aggregates 30+ sources (ChEMBL, DrugBank, TTD, PharmGKB,
+ * GuideToPharmacology, CIViC, …) and reports per-interaction source counts,
+ * which the caller uses as a confidence signal.
+ */
+export interface DgidbInteraction {
+    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;
+    }[];
+}
+export interface DgidbResult {
+    input: string;
+    found: boolean;
+    interactions: DgidbInteraction[];
+    /** Interactions this input had before `limit` trimmed them. */
+    totalInteractions: number;
+}
+export interface DgidbFilters {
+    interactionTypes?: string[];
+    sourceDbs?: string[];
+    minSources?: number;
+    includeAttributes?: boolean;
+    limit?: number;
+}
+/**
+ * Query DGIdb for interactions of the given genes or drugs.
+ *
+ * `onPartialErrors` receives GraphQL partial errors that arrive alongside
+ * usable data — the client itself never logs, so the caller decides.
+ */
+export declare function searchDgidb(inputs: string[], searchType: "gene" | "drug", filters?: DgidbFilters, onPartialErrors?: (errors: {
+    message?: string;
+}[]) => void): Promise<DgidbResult[]>;

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

@@ -0,0 +1,168 @@
+/**
+ * Pure async client functions for the Drug-Gene Interaction Database (DGIdb)
+ * GraphQL API. Free, no key required.
+ *
+ * DGIdb aggregates 30+ sources (ChEMBL, DrugBank, TTD, PharmGKB,
+ * GuideToPharmacology, CIViC, …) and reports per-interaction source counts,
+ * which the caller uses as a confidence signal.
+ */
+import { z } from "zod";
+import { apiFetchValidated, describeApiError } from "./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. 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(),
+});
+/** PMIDs kept per interaction — the count travels for the rest. */
+const MAX_PMIDS = 5;
+/** Attributes kept per interaction, and the per-value character ceiling. */
+const MAX_ATTRIBUTES = 10;
+const MAX_ATTRIBUTE_CHARS = 160;
+function mapInteraction(raw, perspective, inputSide, includeAttributes) {
+    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 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, MAX_PMIDS),
+        ...(includeAttributes
+            ? {
+                attributes: (raw.interactionAttributes ?? []).slice(0, MAX_ATTRIBUTES).map((a) => ({
+                    name: a.name ?? "",
+                    value: (a.value ?? "").slice(0, MAX_ATTRIBUTE_CHARS),
+                })),
+            }
+            : {}),
+    };
+}
+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.sourceDbs?.length) {
+        const needles = filters.sourceDbs.map((s) => s.toLowerCase());
+        out = out.filter((i) => i.sources.some((s) => needles.some((n) => s.toLowerCase().includes(n))));
+    }
+    const minSources = filters.minSources ?? 1;
+    if (minSources > 0) {
+        out = out.filter((i) => i.sourceCount >= minSources);
+    }
+    return out;
+}
+/**
+ * Query DGIdb for interactions of the given genes or drugs.
+ *
+ * `onPartialErrors` receives GraphQL partial errors that arrive alongside
+ * usable data — the client itself never logs, so the caller decides.
+ */
+export async function searchDgidb(inputs, searchType, filters = {}, onPartialErrors) {
+    const isGene = searchType === "gene";
+    const res = await apiFetchValidated(DGIDB_GRAPHQL_URL, DgidbResponseSchema, {
+        method: "POST",
+        headers: { "Content-Type": "application/json" },
+        body: JSON.stringify({
+            query: isGene ? GENE_INTERACTIONS_QUERY : DRUG_INTERACTIONS_QUERY,
+            variables: { [isGene ? "genes" : "drugs"]: 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)
+        onPartialErrors?.(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 limit = filters.limit ?? 20;
+    return inputs.map((input) => {
+        const node = nodeMap.get(input.toLowerCase());
+        if (!node)
+            return { input, found: false, interactions: [], totalInteractions: 0 };
+        const inputSide = isGene ? { geneName: node.name } : { drugName: node.name, drugConceptId: node.conceptId ?? undefined };
+        const mapped = (node.interactions ?? []).map((raw) => mapInteraction(raw, searchType, inputSide, filters.includeAttributes ?? false));
+        const filtered = applyFilters(mapped, filters);
+        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), totalInteractions: sorted.length };
+    });
+}

package/dist/tools/lib/disgenet-client.d.ts

@@ -0,0 +1,56 @@
+/**
+ * Pure async client functions for DisGeNET gene-disease associations (GDAs).
+ *
+ * Requires a DisGeNET API key; `getDisgenetHeaders` throws when it is absent.
+ */
+import { z } from "zod";
+declare const GdaSchema: z.ZodPipe<z.ZodObject<{
+    gene_symbol: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+    gene_name: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+    geneid: z.ZodOptional<z.ZodNullable<z.ZodNumber>>;
+    disease_name: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+    diseaseid: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+    disease_type: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+    score: z.ZodOptional<z.ZodNullable<z.ZodNumber>>;
+    ei: z.ZodOptional<z.ZodNullable<z.ZodNumber>>;
+    year_initial: z.ZodOptional<z.ZodNullable<z.ZodNumber>>;
+    year_final: z.ZodOptional<z.ZodNullable<z.ZodNumber>>;
+    pmid_count: z.ZodOptional<z.ZodNullable<z.ZodNumber>>;
+    source: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+}, z.core.$strip>, z.ZodTransform<{
+    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;
+}, {
+    gene_symbol?: string | null | undefined;
+    gene_name?: string | null | undefined;
+    geneid?: number | null | undefined;
+    disease_name?: string | null | undefined;
+    diseaseid?: string | null | undefined;
+    disease_type?: string | null | undefined;
+    score?: number | null | undefined;
+    ei?: number | null | undefined;
+    year_initial?: number | null | undefined;
+    year_final?: number | null | undefined;
+    pmid_count?: number | null | undefined;
+    source?: string | null | undefined;
+}>>;
+export type Gda = z.infer<typeof GdaSchema>;
+export type DisgenetSearchType = "gene" | "disease";
+export type DisgenetSource = "ALL" | "CURATED" | "ANIMAL_MODELS" | "BEFREE";
+export interface DisgenetSearchOptions {
+    minScore?: number;
+    source?: DisgenetSource;
+    limit?: number;
+}
+export declare function searchDisgenet(apiKey: string, query: string, searchType: DisgenetSearchType, options?: DisgenetSearchOptions): Promise<Gda[]>;
+export {};

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

@@ -0,0 +1,59 @@
+/**
+ * Pure async client functions for DisGeNET gene-disease associations (GDAs).
+ *
+ * Requires a DisGeNET API key; `getDisgenetHeaders` throws when it is absent.
+ */
+import { z } from "zod";
+import { apiFetchValidated, describeApiError } from "./api-utils.js";
+import { DISGENET_BASE, getDisgenetHeaders } from "./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 async function searchDisgenet(apiKey, query, searchType, options = {}) {
+    const headers = getDisgenetHeaders(apiKey);
+    const minScore = options.minScore ?? 0.1;
+    const limit = options.limit ?? 25;
+    const source = options.source ?? "ALL";
+    const path = searchType === "gene" ? `gene/${encodeURIComponent(query)}` : `disease/${encodeURIComponent(query)}`;
+    let url = `${DISGENET_BASE}/gda/${path}?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.
+    return res.value;
+}