@inflexa-ai/harness 0.30.3 → 0.31.0

package/dist/contracts/target-dossier.d.ts

@@ -140,8 +140,8 @@ export declare const EntitySchema: z.ZodObject<{
     displayName: z.ZodString;
     entityType: z.ZodEnum<{
         gene: "gene";
-        rna: "rna";
         protein: "protein";
+        rna: "rna";
         complex: "complex";
     }>;
     ontology: z.ZodString;
@@ -5985,8 +5985,8 @@ export declare const DossierSchema: z.ZodObject<{
         displayName: z.ZodString;
         entityType: z.ZodEnum<{
             gene: "gene";
-            rna: "rna";
             protein: "protein";
+            rna: "rna";
             complex: "complex";
         }>;
         ontology: z.ZodString;
@@ -9243,64 +9243,6 @@ export type Dossier = z.infer<typeof DossierSchema>;
  * and validates the complete dossier against `DossierSchema`.
  */
 export declare const DossierBodySchema: z.ZodObject<{
-    drug_interactions: z.ZodDiscriminatedUnion<[z.ZodObject<{
-        coverage: z.ZodLiteral<"available">;
-        data: z.ZodObject<{
-            rows: z.ZodArray<z.ZodObject<{
-                drug_id: z.ZodNullable<z.ZodString>;
-                drug_name: z.ZodString;
-                best_score: z.ZodNumber;
-                predicates: z.ZodArray<z.ZodString>;
-                sources: z.ZodArray<z.ZodString>;
-                paper_count: z.ZodNumber;
-                dominant_direction: z.ZodEnum<{
-                    unknown: "unknown";
-                    positive: "positive";
-                    negative: "negative";
-                    mixed: "mixed";
-                }>;
-                has_human_evidence: z.ZodBoolean;
-                has_clinical_evidence: z.ZodBoolean;
-                evidence: z.ZodArray<z.ZodObject<{
-                    pmid: z.ZodOptional<z.ZodString>;
-                    doi: z.ZodOptional<z.ZodString>;
-                    accession: z.ZodOptional<z.ZodString>;
-                    source: z.ZodString;
-                    predicate: z.ZodOptional<z.ZodString>;
-                    score: z.ZodOptional<z.ZodNumber>;
-                    strength: z.ZodOptional<z.ZodString>;
-                    is_human: z.ZodOptional<z.ZodBoolean>;
-                    is_clinical: z.ZodOptional<z.ZodBoolean>;
-                    excerpt: z.ZodOptional<z.ZodString>;
-                    metadata: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
-                    regulatory_reference: z.ZodOptional<z.ZodObject<{
-                        document: z.ZodString;
-                        section: z.ZodOptional<z.ZodString>;
-                        doc_id: z.ZodOptional<z.ZodString>;
-                        doc_url: z.ZodOptional<z.ZodString>;
-                    }, z.core.$strip>>;
-                }, z.core.$strip>>;
-            }, z.core.$strip>>;
-        }, z.core.$strip>;
-        dropped_count: z.ZodOptional<z.ZodNumber>;
-        inference_path: z.ZodOptional<z.ZodString>;
-        truncated: z.ZodOptional<z.ZodBoolean>;
-    }, z.core.$strip>, z.ZodObject<{
-        coverage: z.ZodLiteral<"queried_no_data">;
-        error: z.ZodOptional<z.ZodObject<{
-            message: z.ZodString;
-            source: z.ZodOptional<z.ZodString>;
-        }, z.core.$strip>>;
-        inference_path: z.ZodOptional<z.ZodString>;
-    }, z.core.$strip>, z.ZodObject<{
-        coverage: z.ZodLiteral<"filtered">;
-        filter: z.ZodString;
-        dropped_count: z.ZodNumber;
-        inference_path: z.ZodOptional<z.ZodString>;
-    }, z.core.$strip>, z.ZodObject<{
-        coverage: z.ZodLiteral<"not_loaded">;
-        reason: z.ZodOptional<z.ZodString>;
-    }, z.core.$strip>], "coverage">;
     tractability: z.ZodDiscriminatedUnion<[z.ZodObject<{
         coverage: z.ZodLiteral<"available">;
         data: z.ZodObject<{
@@ -9348,8 +9290,8 @@ export declare const DossierBodySchema: z.ZodObject<{
         displayName: z.ZodString;
         entityType: z.ZodEnum<{
             gene: "gene";
-            rna: "rna";
             protein: "protein";
+            rna: "rna";
             complex: "complex";
         }>;
         ontology: z.ZodString;
@@ -9647,6 +9589,64 @@ export declare const DossierBodySchema: z.ZodObject<{
         coverage: z.ZodLiteral<"not_loaded">;
         reason: z.ZodOptional<z.ZodString>;
     }, z.core.$strip>], "coverage">;
+    drug_interactions: z.ZodDiscriminatedUnion<[z.ZodObject<{
+        coverage: z.ZodLiteral<"available">;
+        data: z.ZodObject<{
+            rows: z.ZodArray<z.ZodObject<{
+                drug_id: z.ZodNullable<z.ZodString>;
+                drug_name: z.ZodString;
+                best_score: z.ZodNumber;
+                predicates: z.ZodArray<z.ZodString>;
+                sources: z.ZodArray<z.ZodString>;
+                paper_count: z.ZodNumber;
+                dominant_direction: z.ZodEnum<{
+                    unknown: "unknown";
+                    positive: "positive";
+                    negative: "negative";
+                    mixed: "mixed";
+                }>;
+                has_human_evidence: z.ZodBoolean;
+                has_clinical_evidence: z.ZodBoolean;
+                evidence: z.ZodArray<z.ZodObject<{
+                    pmid: z.ZodOptional<z.ZodString>;
+                    doi: z.ZodOptional<z.ZodString>;
+                    accession: z.ZodOptional<z.ZodString>;
+                    source: z.ZodString;
+                    predicate: z.ZodOptional<z.ZodString>;
+                    score: z.ZodOptional<z.ZodNumber>;
+                    strength: z.ZodOptional<z.ZodString>;
+                    is_human: z.ZodOptional<z.ZodBoolean>;
+                    is_clinical: z.ZodOptional<z.ZodBoolean>;
+                    excerpt: z.ZodOptional<z.ZodString>;
+                    metadata: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+                    regulatory_reference: z.ZodOptional<z.ZodObject<{
+                        document: z.ZodString;
+                        section: z.ZodOptional<z.ZodString>;
+                        doc_id: z.ZodOptional<z.ZodString>;
+                        doc_url: z.ZodOptional<z.ZodString>;
+                    }, z.core.$strip>>;
+                }, z.core.$strip>>;
+            }, z.core.$strip>>;
+        }, z.core.$strip>;
+        dropped_count: z.ZodOptional<z.ZodNumber>;
+        inference_path: z.ZodOptional<z.ZodString>;
+        truncated: z.ZodOptional<z.ZodBoolean>;
+    }, z.core.$strip>, z.ZodObject<{
+        coverage: z.ZodLiteral<"queried_no_data">;
+        error: z.ZodOptional<z.ZodObject<{
+            message: z.ZodString;
+            source: z.ZodOptional<z.ZodString>;
+        }, z.core.$strip>>;
+        inference_path: z.ZodOptional<z.ZodString>;
+    }, z.core.$strip>, z.ZodObject<{
+        coverage: z.ZodLiteral<"filtered">;
+        filter: z.ZodString;
+        dropped_count: z.ZodNumber;
+        inference_path: z.ZodOptional<z.ZodString>;
+    }, z.core.$strip>, z.ZodObject<{
+        coverage: z.ZodLiteral<"not_loaded">;
+        reason: z.ZodOptional<z.ZodString>;
+    }, z.core.$strip>], "coverage">;
     clinical_development: z.ZodObject<{
         trials: z.ZodDiscriminatedUnion<[z.ZodObject<{
             coverage: z.ZodLiteral<"available">;

package/dist/execution/run-synthesis.js

@@ -33,6 +33,7 @@ import { BiologicalThemeSchema, KeyReferenceSchema, RunSynthesisSchema, Synthesi
 import { synthesisAgentPrompt } from "../prompts/synthesis-agent.js";
 import { composeSystemPrompt } from "../agents/system-prompt.js";
 import { runDir } from "../workspace/paths.js";
+import { decodeObjectString } from "../lib/zod-issues.js";
 import { runToTerminal } from "../loop/run-to-terminal.js";
 import { passthroughStep } from "../loop/run-step.js";
 import { defineTool } from "../tools/define-tool.js";
@@ -262,17 +263,21 @@ function buildValidateTool(ctx) {
             "field-by-field synthesis schema is the arg schema of " +
             "submit_synthesis — this tool deliberately does not restate it. " +
             "Non-terminal: call as often as needed to iterate toward a clean " +
-            "synthesis, then submit_synthesis.",
+            "synthesis, then submit_synthesis. A candidate that arrives as a " +
+            "JSON-encoded string is decoded before the checks run, so the " +
+            "result describes the synthesis inside the string.",
         // Deliberately permissive: a structurally-invalid candidate must reach
         // `execute` so the model gets a structured {valid:false, issues} result —
         // including semantic issues — instead of a bare Zod rejection at the loop's
         // input boundary. `execute` re-parses against RunSynthesisSchema itself.
+        // The permissive schema also means the loop's string repair never runs
+        // here, so `execute` decodes a JSON-encoded string itself.
         inputSchema: z.object({
             synthesis: z.unknown().describe("The candidate synthesis, in any shape. Field-by-field schema: see submit_synthesis."),
         }),
         describeCall: "none",
         execute: async (input) => {
-            const result = fullyValidate(input.synthesis, ctx);
+            const result = fullyValidate(decodeObjectString(input.synthesis), ctx);
             return ok(result.valid ? { valid: true, issues: [] } : { valid: false, issues: result.issues });
         },
     });

package/dist/lib/zod-issues.d.ts

@@ -82,3 +82,11 @@ export declare function hintForZodIssue(issue: z.core.$ZodIssue, input: unknown)
  * is not re-examined — one pass, no recursion — and no input causes a throw.
  */
 export declare function repairToolInput(input: unknown, error: z.ZodError): unknown | undefined;
+/**
+ * Decode a value that a model sent as a JSON-encoded object string, with or
+ * without a wrapper artifact. The decoded object is returned when the string
+ * parses to one. Each other value comes back as it is, thus a caller can apply
+ * this to an argument of any type. This is the repair that `repairToolInput`
+ * applies at the loop boundary, for a tool whose schema accepts the string.
+ */
+export declare function decodeObjectString(value: unknown): unknown;

package/dist/lib/zod-issues.js

@@ -131,6 +131,19 @@ export function repairToolInput(input, error) {
         return undefined;
     }
 }
+/**
+ * Decode a value that a model sent as a JSON-encoded object string, with or
+ * without a wrapper artifact. The decoded object is returned when the string
+ * parses to one. Each other value comes back as it is, thus a caller can apply
+ * this to an argument of any type. This is the repair that `repairToolInput`
+ * applies at the loop boundary, for a tool whose schema accepts the string.
+ */
+export function decodeObjectString(value) {
+    if (typeof value !== "string" || value.length > MAX_REPAIRABLE_STRING_LENGTH)
+        return value;
+    const parsed = parseAs(value, "object") ?? parseAs(stripWrappers(value).text, "object");
+    return parsed === undefined ? value : parsed.value;
+}
 /**
  * The measurement of a string that broke its maximum length, or `undefined` for
  * any other issue.

package/dist/literature/sources/semantic-scholar.d.ts

@@ -1,4 +1,38 @@
+/**
+ * Absence policy: Semantic Scholar gives each requested key, and it sends an
+ * explicit `null` for an absent value such as `abstract` or `year`. An absent
+ * `venue` is the empty string.
+ */
+import { z } from "zod";
 import { type SourceHttpOptions, type SourceHttpResult } from "./http.js";
+export declare const ExactPaperSchema: z.ZodObject<{
+    title: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+    abstract: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+    year: z.ZodOptional<z.ZodNullable<z.ZodNumber>>;
+    venue: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+    citationCount: z.ZodOptional<z.ZodNullable<z.ZodNumber>>;
+    url: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+    authors: z.ZodOptional<z.ZodArray<z.ZodObject<{
+        name: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+    }, z.core.$strip>>>;
+    externalIds: z.ZodOptional<z.ZodNullable<z.ZodRecord<z.ZodString, z.ZodUnion<readonly [z.ZodString, z.ZodNumber]>>>>;
+    paperId: z.ZodString;
+}, z.core.$loose>;
+export declare const SearchResponseSchema: z.ZodObject<{
+    data: z.ZodOptional<z.ZodArray<z.ZodObject<{
+        paperId: z.ZodOptional<z.ZodString>;
+        title: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+        abstract: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+        year: z.ZodOptional<z.ZodNullable<z.ZodNumber>>;
+        venue: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+        citationCount: z.ZodOptional<z.ZodNullable<z.ZodNumber>>;
+        url: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+        authors: z.ZodOptional<z.ZodArray<z.ZodObject<{
+            name: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+        }, z.core.$strip>>>;
+        externalIds: z.ZodOptional<z.ZodNullable<z.ZodRecord<z.ZodString, z.ZodUnion<readonly [z.ZodString, z.ZodNumber]>>>>;
+    }, z.core.$loose>>>;
+}, z.core.$strip>;
 export interface SemanticScholarPaper {
     id: string;
     title?: string;

package/dist/literature/sources/semantic-scholar.js

@@ -1,3 +1,8 @@
+/**
+ * Absence policy: Semantic Scholar gives each requested key, and it sends an
+ * explicit `null` for an absent value such as `abstract` or `year`. An absent
+ * `venue` is the empty string.
+ */
 import { z } from "zod";
 import { requestJson } from "./http.js";
 const BASE_URL = "https://api.semanticscholar.org/graph/v1";
@@ -12,15 +17,21 @@ const WirePaperSchema = z
     citationCount: z.number().nullable().optional(),
     url: z.string().nullable().optional(),
     authors: z.array(z.object({ name: z.string().nullable().optional() })).optional(),
-    externalIds: z.record(z.string(), z.unknown()).nullable().optional(),
+    // An external id is a string, but `CorpusId` is a JSON integer on every
+    // observed paper. A string-only value type drops it at the map site below.
+    externalIds: z
+        .record(z.string(), z.union([z.string(), z.number()]))
+        .nullable()
+        .optional(),
 })
     .passthrough();
-const ExactPaperSchema = WirePaperSchema.extend({ paperId: z.string() });
-const SearchResponseSchema = z.object({ data: z.array(WirePaperSchema).optional() });
+export const ExactPaperSchema = WirePaperSchema.extend({ paperId: z.string() });
+export const SearchResponseSchema = z.object({ data: z.array(WirePaperSchema).optional() });
+/** Give one text form to each external id, thus a numeric `CorpusId` reaches a caller that keys on a string. */
 function stringExternalIds(value) {
     if (value === null || value === undefined)
         return undefined;
-    const entries = Object.entries(value).filter((entry) => typeof entry[1] === "string");
+    const entries = Object.entries(value).map(([key, raw]) => [key, typeof raw === "string" ? raw : String(raw)]);
     return entries.length === 0 ? undefined : Object.fromEntries(entries);
 }
 function mapPaper(raw) {

package/dist/tools/bio/chembl.js

@@ -38,9 +38,10 @@ const inputSchema = z
         .describe("Which ChEMBL lookup to run; each names its params and return fields.\n" +
         "'compounds' (query + searchType) — molecules by target, name or SMILES: resolve a named compound to its ID and structure, or list " +
         "what was assayed against a target. → chemblId, preferredCompoundName, canonicalSmiles, molecularWeight, alogp, molecularFormula.\n" +
-        "'drug' (query) — the drug registry by drug name or indication: 'what treats X?', 'is Y approved, since when?'. → moleculeChemblId, " +
-        "preferredName, maxPhase (4 = approved), moleculeType, firstApproval, indication. If the drug endpoint is empty it falls back to a " +
-        "max_phase >= 4 molecule search, whose rows carry indication: null.\n" +
+        "'drug' (query) — approved drugs by indication or by drug name: 'what treats X?', 'is Y approved, since when?'. → moleculeChemblId, " +
+        "preferredName, maxPhase (4 = approved), moleculeType, firstApproval, indication. A disease term reads the curated indication " +
+        "registry, highest phase first; a query that matches no disease term reads the approved molecules (max_phase >= 4) instead, and " +
+        "their indications come back with them.\n" +
         "'mechanism' (chemblId, molecule only) — curated mechanism of ONE molecule: 'how does X work?'. → mechanismOfAction, actionType " +
         "(INHIBITOR, AGONIST, …), targetChemblId + targetName, moleculeChemblId. Curated mainly for clinical/approved molecules, so tool " +
         "compounds often have none.\n" +

package/dist/tools/bio/drug-gene-interactions.d.ts

@@ -18,7 +18,6 @@
  */
 import type { Logger } from "../../lib/logger.js";
 import { type DgidbResult } from "../lib/dgidb-client.js";
-import { type DrugResult } from "../lib/drugbank-client.js";
 import { type PharmgkbAnnotation } from "../lib/pharmgkb-client.js";
 declare const SOURCES: readonly ["dgidb", "drugbank", "pharmgkb"];
 type Source = (typeof SOURCES)[number];
@@ -30,26 +29,15 @@ interface SourceOutcome {
 }
 /**
  * A DrugBank record projected for context. `includeDrugRecord` decides whether
- * the five prose fields arrive whole or as previews — five 500-character fields
- * across ten records is 25k characters of narrative that a drug-vs-gene
- * question rarely needs.
+ * the description arrives whole or as a preview — a 500-character field across
+ * ten records is narrative that a drug-vs-gene question rarely needs.
  */
 interface ProjectedDrug {
     drugbankId: string;
     name: string;
     type: string;
     groups: string[];
-    categories: string[];
-    halfLife: string;
-    targets: DrugResult["targets"];
-    targetCount: number;
-    interactions: DrugResult["interactions"];
-    interactionCount: number;
     description: string;
-    indication: string;
-    pharmacodynamics: string;
-    mechanismOfAction: string;
-    toxicity: string;
     proseTruncated: boolean;
 }
 interface DrugGeneOutput {

package/dist/tools/bio/drug-gene-interactions.js

@@ -29,9 +29,6 @@ const MAX_LIMIT = 200;
 const MAX_INPUTS = 25;
 /** Prose kept per DrugBank field when the full record is not requested. */
 const PROSE_PREVIEW_CHARS = 200;
-/** Targets and interactions kept per DrugBank record. */
-const MAX_DRUG_TARGETS = 10;
-const MAX_DRUG_INTERACTIONS = 10;
 const inputSchema = z.object({
     query: z
         .union([z.string().min(1), z.array(z.string().min(1)).min(1).max(MAX_INPUTS)])
@@ -47,7 +44,8 @@ const inputSchema = z.object({
         .optional()
         .describe("Corpora to query in parallel. Default ['dgidb'] ALONE — it aggregates the other two, so add them only for what they uniquely hold. " +
         "'dgidb': 30+ aggregated sources, per-interaction source count as confidence; the only one that batches. " +
-        "'drugbank': the curated drug RECORD (indication, pharmacodynamics, mechanism, toxicity, half-life, DDIs); needs DRUGBANK_API_KEY. " +
+        "'drugbank': the curated drug RECORD of the Discovery API (name, description, modality type, approval groups); it carries no indication, " +
+        "pharmacodynamics, mechanism, toxicity, half-life or drug-drug interaction, because that API serves none of them. Needs DRUGBANK_API_KEY. " +
         "'pharmgkb': pharmacogenomic annotations graded 1A…4 (1A guideline-backed); exact match only — 'CYP2D6' resolves, 'cytochrome P450 2D6' does not."),
     limit: z
         .number()
@@ -56,7 +54,7 @@ const inputSchema = z.object({
         .max(MAX_LIMIT)
         .optional()
         .describe(`Max records per identifier per source (default ${DEFAULT_LIMIT}, max ${MAX_LIMIT}). DGIdb rows are ordered by source count descending; ` +
-        "`totalInteractions` gives the pre-trim count."),
+        "`totalInteractions` gives the pre-trim count. DrugBank serves one page of at most 50 records, thus a larger limit still returns at most 50 there."),
     interactionTypes: z.array(z.string()).optional().describe("'dgidb' only. Case-insensitive substring filter on interaction type, e.g. ['inhibitor']."),
     sourceDbs: z.array(z.string()).optional().describe("'dgidb' only. Keep only interactions from these underlying databases (substring), e.g. ['chembl']."),
     minSources: z.number().int().min(1).optional().describe("'dgidb' only. Drop interactions with fewer than this many supporting sources; default 1."),
@@ -67,33 +65,27 @@ const inputSchema = z.object({
     includeDrugRecord: z
         .boolean()
         .optional()
-        .describe(`'drugbank' only. Default FALSE — the five prose fields come back as ${PROSE_PREVIEW_CHARS}-char previews with proseTruncated: true. ` +
+        .describe(`'drugbank' only. Default FALSE — the description comes back as a ${PROSE_PREVIEW_CHARS}-char preview with proseTruncated: true. ` +
         "True for full text; narrow `limit` when you do."),
 });
 function projectDrug(drug, includeFullProse) {
-    const prose = (value) => (includeFullProse ? value : value.slice(0, PROSE_PREVIEW_CHARS));
     return {
         drugbankId: drug.drugbankId,
         name: drug.name,
         type: drug.type,
         groups: drug.groups,
-        categories: drug.categories,
-        halfLife: drug.halfLife,
-        targets: drug.targets.slice(0, MAX_DRUG_TARGETS),
-        targetCount: drug.targets.length,
-        interactions: drug.interactions.slice(0, MAX_DRUG_INTERACTIONS),
-        interactionCount: drug.interactions.length,
-        description: prose(drug.description),
-        indication: prose(drug.indication),
-        pharmacodynamics: prose(drug.pharmacodynamics),
-        mechanismOfAction: prose(drug.mechanismOfAction),
-        toxicity: prose(drug.toxicity),
+        description: includeFullProse ? drug.description : drug.description.slice(0, PROSE_PREVIEW_CHARS),
         proseTruncated: !includeFullProse,
     };
 }
 /**
  * Run one corpus, folding its failure into an `unavailable` outcome so a dead
  * or unkeyed source cannot take down a call the others could answer.
+ *
+ * `unavailable` reports that the corpus was not reached. An empty result is a
+ * complete answer, thus it reports `no_data`. ClinPGx encodes "no annotation" as
+ * an HTTP 404, and its client maps that miss to an empty list before it arrives
+ * here. As a result an unannotated gene reads as `no_data`, not as an outage.
  */
 async function runSource(source, fetch) {
     try {

package/dist/tools/bio/gene-disease-evidence.d.ts

@@ -24,6 +24,7 @@
  * — an accession of that corpus — marks the others `not_applicable` rather
  * than sending them a query they cannot read.
  */
+import type { Logger } from "../../lib/logger.js";
 import { type MutationFrequency } from "../lib/cbioportal-client.js";
 import { type ClinvarVariant } from "../lib/clinvar-client.js";
 import { type Gda } from "../lib/disgenet-client.js";
@@ -57,6 +58,7 @@ interface GeneDiseaseEvidenceOutput {
 export declare function createGeneDiseaseEvidenceTool(deps: {
     ncbiApiKey?: string;
     disgenetApiKey: string;
+    logger?: Logger;
 }): import("../define-tool.js").Tool<{
     query: string;
     queryType: "gene" | "disease" | "variant" | "gwas_study" | "clinvar_accession";
@@ -64,7 +66,7 @@ export declare function createGeneDiseaseEvidenceTool(deps: {
     limit?: number | undefined;
     pValueThreshold?: number | undefined;
     minScore?: number | undefined;
-    disgenetSource?: "ALL" | "CURATED" | "ANIMAL_MODELS" | "BEFREE" | undefined;
+    disgenetSource?: "ALL" | "BIOBANK" | "CHEMBL" | "CLINICALTRIALS" | "CLINGEN" | "CLINPGX" | "CLINVAR" | "CURATED" | "FINNGEN" | "GENCC" | "GWASCAT" | "HPO" | "INFERRED" | "MGD_HUMAN" | "MGD_MOUSE" | "MODELS" | "ORPHANET" | "PHEWASCAT" | "PSYGENET" | "RGD_HUMAN" | "RGD_RAT" | "TEXTMINING_HUMAN" | "TEXTMINING_MODELS" | "UKBIOBANK" | "UNIPROT" | undefined;
     clinicalSignificance?: "pathogenic" | "likely-pathogenic" | "benign" | "likely-benign" | "uncertain" | undefined;
     informativeOnly?: boolean | undefined;
 }, GeneDiseaseEvidenceOutput>;

package/dist/tools/bio/gene-disease-evidence.js

@@ -29,7 +29,7 @@ import { z } from "zod";
 import { defineTool } from "../define-tool.js";
 import { getSomaticMutationFrequencies } from "../lib/cbioportal-client.js";
 import { filterInformative, searchClinvar } from "../lib/clinvar-client.js";
-import { searchDisgenet } from "../lib/disgenet-client.js";
+import { DISGENET_SOURCES, searchDisgenet } from "../lib/disgenet-client.js";
 import { searchGwasCatalog } from "../lib/gwas-catalog-client.js";
 const SOURCES = ["gwas", "disgenet", "clinvar", "cbioportal"];
 const QUERY_TYPES = ["gene", "disease", "variant", "gwas_study", "clinvar_accession"];
@@ -69,7 +69,8 @@ const inputSchema = z.object({
         .string()
         .min(1)
         .describe("The entity, matching `queryType`. gene: a HUGO symbol ('PCSK9'); DisGeNET also takes an Entrez ID, and cBioPortal takes the symbol " +
-        "directly. disease: a disease or trait name ('LDL cholesterol'); DisGeNET also takes a UMLS CUI ('C0006142'). variant: a dbSNP rsID " +
+        "directly. disease: a disease or trait name ('asthma'); the GWAS Catalog needs the exact EFO trait label, and DisGeNET also takes a UMLS " +
+        "CUI ('C0006142'). variant: a dbSNP rsID " +
         "('rs11591147'). gwas_study: a GWAS Catalog study accession ('GCST000392'). clinvar_accession: a ClinVar accession ('VCV000012345', " +
         "'RCV000009910') or a bare variation ID."),
     queryType: z
@@ -106,9 +107,10 @@ const inputSchema = z.object({
         .describe("'gwas' only. P-value ceiling; default 5e-8 (genome-wide significance). Raise for suggestive hits."),
     minScore: z.number().min(0).max(1).optional().describe("'disgenet' only. Minimum GDA score 0–1; default 0.1. Higher = stronger evidence."),
     disgenetSource: z
-        .enum(["ALL", "CURATED", "ANIMAL_MODELS", "BEFREE"])
+        .enum(DISGENET_SOURCES)
         .optional()
-        .describe("'disgenet' only. Provenance filter; default 'ALL'. Prefer 'CURATED' for anything you will quote — 'BEFREE' is text-mined and noisy."),
+        .describe("'disgenet' only. Provenance filter; default 'ALL'. Prefer 'CURATED' for anything you will quote — 'TEXTMINING_HUMAN' and " +
+        "'TEXTMINING_MODELS' are text-mined and noisy, and 'MODELS' is animal-model evidence."),
     clinicalSignificance: z
         .enum(["pathogenic", "likely-pathogenic", "benign", "likely-benign", "uncertain"])
         .optional()
@@ -158,8 +160,10 @@ export function createGeneDiseaseEvidenceTool(deps) {
             "and the drug landscape. Reach here for the underlying records: actual SNPs, effect sizes, scores, pathogenicity calls and somatic mutation " +
             "frequencies with their studies and PMIDs.\n" +
             "ACCEPTED IDENTIFIERS, each named by its `queryType`: a HUGO gene symbol or an Entrez ID ('PCSK9', '5008'); a disease or trait name or a UMLS " +
-            "CUI ('LDL cholesterol', 'C0006142'); a dbSNP rsID ('rs11591147'); a GWAS Catalog study accession ('GCST000392'); and a ClinVar accession " +
-            "('VCV000012345'). The last two read one record back by the accession that an earlier result of this same tool reported.\n" +
+            "CUI ('asthma', 'C0006142'); a dbSNP rsID ('rs11591147'); a GWAS Catalog study accession ('GCST000392'); and a ClinVar accession " +
+            "('VCV000012345'). The last two read one record back by the accession that an earlier result of this same tool reported. " +
+            "The GWAS Catalog matches the EXACT EFO trait label (case-insensitive): 'asthma' resolves, a paraphrase such as 'LDL cholesterol' reads as " +
+            "no_data there ('low density lipoprotein cholesterol measurement' is the label) while the other corpora still answer it.\n" +
             "ALWAYS read `perSource` before concluding anything is absent. 'no_data' means that corpus genuinely has nothing; 'unavailable' means it " +
             "could not be reached (a missing DISGENET_API_KEY lands here — tell the user and proceed with the others); 'not_applicable' means that " +
             "corpus has no lookup for this queryType. Only 'no_data' is evidence of absence, and none is worth retrying unchanged.",
@@ -197,12 +201,11 @@ export function createGeneDiseaseEvidenceTool(deps) {
                     ? runSource("disgenet", async () => {
                         if (!deps.disgenetApiKey)
                             throw new Error("DISGENET_API_KEY is not configured");
-                        const records = await searchDisgenet(deps.disgenetApiKey, input.query, input.queryType === "gene" ? "gene" : "disease", {
+                        return await searchDisgenet(deps.disgenetApiKey, input.query, input.queryType === "gene" ? "gene" : "disease", {
                             limit,
                             ...(input.minScore !== undefined ? { minScore: input.minScore } : {}),
                             ...(input.disgenetSource !== undefined ? { source: input.disgenetSource } : {}),
-                        });
-                        return { records };
+                        }, deps.logger);
                     })
                     : null,
                 selected.includes("clinvar")

package/dist/tools/bio/keys.js

@@ -30,6 +30,7 @@ export function createChemDbTools(keys, deps = {}) {
         geneDiseaseEvidence: createGeneDiseaseEvidenceTool({
             disgenetApiKey: keys.disgenet,
             ...(keys.ncbi ? { ncbiApiKey: keys.ncbi } : {}),
+            ...(deps.logger ? { logger: deps.logger } : {}),
         }),
         drugGeneInteractions: createDrugGeneInteractionsTool({
             drugbankApiKey: keys.drugbank,

package/dist/tools/bio/lookup-annotation.d.ts

@@ -13,7 +13,12 @@
  * schema and made conditionally required by `.refine`, so a malformed call
  * fails at the loop boundary naming the missing field instead of reaching an
  * API request that cannot be built.
+ *
+ * Absence policy: QuickGO gives each key and sends an explicit `null` for an
+ * absent value. Thus a maybe-absent QuickGO field carries `.nullable()`, and
+ * `pathway-client.ts` holds the policy of KEGG and Reactome.
  */
+import { z } from "zod";
 import { type Pathway } from "../lib/pathway-client.js";
 interface GoTerm {
     id: string;
@@ -29,6 +34,44 @@ interface GoAnnotation {
     evidenceCode?: string;
     qualifier?: string;
 }
+export declare const GoTermResponseSchema: z.ZodPipe<z.ZodObject<{
+    results: z.ZodOptional<z.ZodArray<z.ZodObject<{
+        id: z.ZodOptional<z.ZodString>;
+        name: z.ZodOptional<z.ZodString>;
+        definition: z.ZodOptional<z.ZodNullable<z.ZodObject<{
+            text: z.ZodOptional<z.ZodString>;
+        }, z.core.$strip>>>;
+        aspect: z.ZodOptional<z.ZodString>;
+    }, z.core.$strip>>>;
+}, z.core.$strip>, z.ZodTransform<GoTerm[], {
+    results?: {
+        id?: string | undefined;
+        name?: string | undefined;
+        definition?: {
+            text?: string | undefined;
+        } | null | undefined;
+        aspect?: string | undefined;
+    }[] | undefined;
+}>>;
+export declare const GoAnnotationResponseSchema: z.ZodPipe<z.ZodObject<{
+    results: z.ZodOptional<z.ZodArray<z.ZodObject<{
+        geneProductId: z.ZodOptional<z.ZodString>;
+        goId: z.ZodOptional<z.ZodString>;
+        goName: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+        goAspect: z.ZodOptional<z.ZodString>;
+        goEvidence: z.ZodOptional<z.ZodString>;
+        qualifier: z.ZodOptional<z.ZodString>;
+    }, z.core.$strip>>>;
+}, z.core.$strip>, z.ZodTransform<GoAnnotation[], {
+    results?: {
+        geneProductId?: string | undefined;
+        goId?: string | undefined;
+        goName?: string | null | undefined;
+        goAspect?: string | undefined;
+        goEvidence?: string | undefined;
+        qualifier?: string | undefined;
+    }[] | undefined;
+}>>;
 type AnnotationOutput = {
     terms?: GoTerm[];
     annotations?: GoAnnotation[];

package/dist/tools/bio/lookup-annotation.js

@@ -13,6 +13,10 @@
  * schema and made conditionally required by `.refine`, so a malformed call
  * fails at the loop boundary naming the missing field instead of reaching an
  * API request that cannot be built.
+ *
+ * Absence policy: QuickGO gives each key and sends an explicit `null` for an
+ * absent value. Thus a maybe-absent QuickGO field carries `.nullable()`, and
+ * `pathway-client.ts` holds the policy of KEGG and Reactome.
  */
 import { ok } from "neverthrow";
 import { z } from "zod";
@@ -22,11 +26,19 @@ import { getPathwayById, searchPathways } from "../lib/pathway-client.js";
 const QUICKGO_BASE = "https://www.ebi.ac.uk/QuickGO/services";
 const HEADERS = { Accept: "application/json" };
 const DEFAULT_LIMIT = 10;
+/**
+ * The fields that the annotation search must name.
+ *
+ * QuickGO serves the label of a GO term only when the request asks for it. A
+ * request that does not ask gets `"goName": null` on each row, thus every
+ * annotation reads as an identifier with no name.
+ */
+const ANNOTATION_INCLUDE_FIELDS = "goName";
 // 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
+export const GoTermResponseSchema = z
     .object({
     results: z
         .array(z.object({
@@ -43,13 +55,16 @@ const GoTermResponseSchema = z
     definition: t.definition?.text ?? undefined,
     aspect: t.aspect ?? undefined,
 })));
-const GoAnnotationResponseSchema = z
+// QuickGO answers a `goName` with an explicit `null` on each row unless the
+// request names the field. `ANNOTATION_INCLUDE_FIELDS` names it, and `goName`
+// stays nullable because the wire can still send the null.
+export const GoAnnotationResponseSchema = z
     .object({
     results: z
         .array(z.object({
         geneProductId: z.string().optional(),
         goId: z.string().optional(),
-        goName: z.string().optional(),
+        goName: z.string().nullable().optional(),
         goAspect: z.string().optional(),
         goEvidence: z.string().optional(),
         qualifier: z.string().optional(),
@@ -177,7 +192,7 @@ export const lookupAnnotationTool = defineTool({
         }
         if (geneProductId) {
             tasks.push((async () => {
-                const params = new URLSearchParams({ geneProductId, limit: String(cap) });
+                const params = new URLSearchParams({ geneProductId, limit: String(cap), includeFields: ANNOTATION_INCLUDE_FIELDS });
                 if (taxonId)
                     params.set("taxonId", String(taxonId));
                 const res = await apiFetchValidated(`${QUICKGO_BASE}/annotation/search?${params}`, GoAnnotationResponseSchema, { headers: HEADERS });