@inflexa-ai/harness 0.45.1 → 0.46.2

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

@@ -24,7 +24,9 @@
  * — an accession of that corpus — marks the others `not_applicable` rather
  * than sending them a query they cannot read.
  */
+import { z } from "zod";
 import type { Logger } from "../../lib/logger.js";
+import { type Tool } from "../define-tool.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";
@@ -39,14 +41,68 @@ type QueryType = (typeof QUERY_TYPES)[number];
  * normal states the caller must be able to tell apart from genuine no-data —
  * otherwise an unkeyed DisGeNET reads as "no genetic support".
  */
-interface SourceOutcome {
+type SourceOutcome = {
     source: Source;
     status: "ok" | "no_data" | "unavailable" | "not_applicable";
     returned: number;
     totalFound?: number;
     detail?: string;
-}
-interface GeneDiseaseEvidenceOutput {
+};
+declare const inputSchema: z.ZodObject<{
+    query: z.ZodString;
+    queryType: z.ZodEnum<{
+        clinvar_accession: "clinvar_accession";
+        disease: "disease";
+        gene: "gene";
+        gwas_study: "gwas_study";
+        variant: "variant";
+    }>;
+    sources: z.ZodOptional<z.ZodArray<z.ZodEnum<{
+        cbioportal: "cbioportal";
+        clinvar: "clinvar";
+        disgenet: "disgenet";
+        gwas: "gwas";
+    }>>>;
+    limit: z.ZodOptional<z.ZodNumber>;
+    pValueThreshold: z.ZodOptional<z.ZodNumber>;
+    minScore: z.ZodOptional<z.ZodNumber>;
+    disgenetSource: z.ZodOptional<z.ZodEnum<{
+        ALL: "ALL";
+        BIOBANK: "BIOBANK";
+        CHEMBL: "CHEMBL";
+        CLINGEN: "CLINGEN";
+        CLINICALTRIALS: "CLINICALTRIALS";
+        CLINPGX: "CLINPGX";
+        CLINVAR: "CLINVAR";
+        CURATED: "CURATED";
+        FINNGEN: "FINNGEN";
+        GENCC: "GENCC";
+        GWASCAT: "GWASCAT";
+        HPO: "HPO";
+        INFERRED: "INFERRED";
+        MGD_HUMAN: "MGD_HUMAN";
+        MGD_MOUSE: "MGD_MOUSE";
+        MODELS: "MODELS";
+        ORPHANET: "ORPHANET";
+        PHEWASCAT: "PHEWASCAT";
+        PSYGENET: "PSYGENET";
+        RGD_HUMAN: "RGD_HUMAN";
+        RGD_RAT: "RGD_RAT";
+        TEXTMINING_HUMAN: "TEXTMINING_HUMAN";
+        TEXTMINING_MODELS: "TEXTMINING_MODELS";
+        UKBIOBANK: "UKBIOBANK";
+        UNIPROT: "UNIPROT";
+    }>>;
+    clinicalSignificance: z.ZodOptional<z.ZodEnum<{
+        benign: "benign";
+        "likely-benign": "likely-benign";
+        "likely-pathogenic": "likely-pathogenic";
+        pathogenic: "pathogenic";
+        uncertain: "uncertain";
+    }>>;
+    informativeOnly: z.ZodOptional<z.ZodBoolean>;
+}, z.core.$strip>;
+type GeneDiseaseEvidenceOutput = {
     query: string;
     queryType: QueryType;
     perSource: SourceOutcome[];
@@ -54,20 +110,10 @@ interface GeneDiseaseEvidenceOutput {
     disgenet?: Gda[];
     clinvar?: ClinvarVariant[];
     cbioportal?: MutationFrequency[];
-}
+};
 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";
-    sources?: ("clinvar" | "gwas" | "disgenet" | "cbioportal")[] | undefined;
-    limit?: number | undefined;
-    pValueThreshold?: number | undefined;
-    minScore?: number | 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>;
+}): Tool<z.infer<typeof inputSchema>, GeneDiseaseEvidenceOutput>;
 export {};

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

@@ -24,6 +24,8 @@
  * — an accession of that corpus — marks the others `not_applicable` rather
  * than sending them a query they cannot read.
  */
+import { errorMessageOf } from "../../lib/thrown.js";
+import { textOf } from "../../lib/unknown-text.js";
 import { ok } from "neverthrow";
 import { z } from "zod";
 import { defineTool } from "../define-tool.js";
@@ -134,7 +136,7 @@ async function runSource(source, fetch) {
                 source,
                 status: records.length > 0 ? "ok" : "no_data",
                 returned: records.length,
-                ...(totalFound !== undefined ? { totalFound } : {}),
+                totalFound,
             },
             records,
         };
@@ -145,7 +147,7 @@ async function runSource(source, fetch) {
                 source,
                 status: "unavailable",
                 returned: 0,
-                detail: error instanceof Error ? error.message : String(error),
+                detail: errorMessageOf(error) ?? textOf(error),
             },
             records: [],
         };
@@ -190,9 +192,11 @@ export function createGeneDiseaseEvidenceTool(deps) {
                 selected.includes("gwas")
                     ? runSource("gwas", async () => {
                         const searchType = GWAS_SEARCH_TYPES[input.queryType];
+                        if (searchType === undefined)
+                            throw new Error(`the gwas source has no search type for "${input.queryType}"`);
                         const res = await searchGwasCatalog(input.query, searchType, {
                             limit,
-                            ...(input.pValueThreshold !== undefined ? { pValueThreshold: input.pValueThreshold } : {}),
+                            pValueThreshold: input.pValueThreshold,
                         });
                         return { records: res.associations, totalFound: res.totalFound };
                     })
@@ -203,8 +207,8 @@ export function createGeneDiseaseEvidenceTool(deps) {
                             throw new Error("DISGENET_API_KEY is not configured");
                         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 } : {}),
+                            minScore: input.minScore,
+                            source: input.disgenetSource,
                         }, deps.logger);
                     })
                     : null,
@@ -212,7 +216,7 @@ export function createGeneDiseaseEvidenceTool(deps) {
                     ? runSource("clinvar", async () => {
                         const res = await searchClinvar(deps.ncbiApiKey, input.query, {
                             limit,
-                            ...(input.clinicalSignificance !== undefined ? { clinicalSignificance: input.clinicalSignificance } : {}),
+                            clinicalSignificance: input.clinicalSignificance,
                         });
                         const variants = (input.informativeOnly ?? true) ? filterInformative(res.variants) : res.variants;
                         return { records: variants, totalFound: res.totalFound };

package/dist/tools/bio/gene-preclinical-profile.d.ts

@@ -17,7 +17,7 @@
 import { type SupportedSpecies, type TissueRow } from "../lib/bgee-client.js";
 import { type MpTerm, type ViabilityCall, type ViabilityCategory } from "../lib/impc-client.js";
 import { type MonarchPhenotypeAssociation } from "../lib/monarch-client.js";
-interface BoundedSpeciesEntry {
+type BoundedSpeciesEntry = {
     species: SupportedSpecies;
     taxonId: number;
     ensemblId: string;
@@ -26,19 +26,19 @@ interface BoundedSpeciesEntry {
     tissueCount: number;
     /** Tissues that passed `minRank`, before `tissueLimit`. */
     tissuesAboveMinRank: number;
-}
-interface ExpressionHalf {
+};
+type ExpressionHalf = {
     humanEnsemblId: string | null;
     bySpecies: BoundedSpeciesEntry[];
     notFound: string[];
-}
+};
 /**
  * One curated human phenotype. The HPO ancestor closure of the source record
  * is dropped here: it exists so a dossier collector can resolve an organ system
  * by identifier, and it runs to hundreds of ids that a reader never uses.
  */
 type HumanPhenotypeTerm = Omit<MonarchPhenotypeAssociation, "ancestorIds">;
-interface HumanPhenotypeHalf {
+type HumanPhenotypeHalf = {
     /** The curie Monarch was queried by, e.g. `HGNC:1100`; null when the symbol did not anchor on HGNC. */
     geneCurie: string | null;
     hpoTerms: HumanPhenotypeTerm[];
@@ -46,8 +46,8 @@ interface HumanPhenotypeHalf {
     phenotypeCount: number;
     /** True when `phenotypeLimit` trimmed `hpoTerms`; `phenotypeCount` is the real total. */
     phenotypesTrimmed: boolean;
-}
-interface KnockoutHalf {
+};
+type KnockoutHalf = {
     mouseMarkerSymbol: string | null;
     mgiAccessionId: string | null;
     viability: ViabilityCategory;
@@ -58,7 +58,7 @@ interface KnockoutHalf {
     phenotypeCount: number;
     /** True when `phenotypeLimit` trimmed `mpTerms`; `phenotypeCount` is the real total. */
     phenotypesTrimmed: boolean;
-}
+};
 type PreclinicalOutput = {
     geneSymbol: string;
     expression?: ExpressionHalf;
@@ -67,9 +67,9 @@ type PreclinicalOutput = {
 };
 export declare const genePreclinicalProfileTool: import("../define-tool.js").Tool<{
     geneSymbol: string;
-    include?: ("phenotypes" | "expression" | "knockout")[] | undefined;
-    species?: ("homo_sapiens" | "mus_musculus" | "rattus_norvegicus" | "canis_lupus_familiaris" | "macaca_mulatta")[] | undefined;
-    minRank?: "low" | "medium" | "high" | "absent" | undefined;
+    include?: ("expression" | "knockout" | "phenotypes")[] | undefined;
+    species?: ("canis_lupus_familiaris" | "homo_sapiens" | "macaca_mulatta" | "mus_musculus" | "rattus_norvegicus")[] | undefined;
+    minRank?: "absent" | "high" | "low" | "medium" | undefined;
     tissueLimit?: number | undefined;
     phenotypeLimit?: number | undefined;
 }, PreclinicalOutput>;

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

@@ -7,7 +7,7 @@ import type { Tool } from "../define-tool.js";
  * may be empty when its source is unconfigured — the tool surfaces the
  * resulting auth failure as a normal tool error.
  */
-export interface BioToolKeys {
+export type BioToolKeys = {
     readonly drugbank: string;
     readonly disgenet: string;
     readonly epaCcte: string;
@@ -15,7 +15,7 @@ export interface BioToolKeys {
     readonly github?: string;
     readonly semanticScholar?: string;
     readonly amass?: string;
-}
+};
 /**
  * The NCBI-backed literature tool, built from the shared key slice.
  *

package/dist/tools/bio/keys.js

@@ -31,12 +31,12 @@ export function createChemDbTools(keys, deps = {}) {
     return {
         geneDiseaseEvidence: createGeneDiseaseEvidenceTool({
             disgenetApiKey: keys.disgenet,
-            ...(keys.ncbi ? { ncbiApiKey: keys.ncbi } : {}),
-            ...(deps.logger ? { logger: deps.logger } : {}),
+            ncbiApiKey: keys.ncbi,
+            logger: deps.logger,
         }),
         drugGeneInteractions: createDrugGeneInteractionsTool({
             drugbankApiKey: keys.drugbank,
-            ...(deps.logger ? { logger: deps.logger } : {}),
+            logger: deps.logger,
         }),
         comptox: createComptoxTool({ apiKey: keys.epaCcte }),
     };

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

@@ -20,20 +20,20 @@
  */
 import { z } from "zod";
 import { type Pathway } from "../lib/pathway-client.js";
-interface GoTerm {
+type GoTerm = {
     id: string;
     name: string;
     definition?: string;
     aspect?: string;
-}
-interface GoAnnotation {
+};
+type GoAnnotation = {
     geneProductId: string;
     goId: string;
     goName: string;
     aspect?: string;
     evidenceCode?: string;
     qualifier?: string;
-}
+};
 export declare const GoTermResponseSchema: z.ZodPipe<z.ZodObject<{
     results: z.ZodOptional<z.ZodArray<z.ZodObject<{
         id: z.ZodOptional<z.ZodString>;
@@ -79,7 +79,7 @@ type AnnotationOutput = {
     pathways: Pathway[];
 };
 export declare const lookupAnnotationTool: import("../define-tool.js").Tool<{
-    vocabulary: "kegg" | "reactome" | "go" | "pathways";
+    vocabulary: "go" | "kegg" | "pathways" | "reactome";
     query?: string | undefined;
     pathwayId?: string | undefined;
     goId?: string | undefined;

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

@@ -103,6 +103,7 @@ const inputSchema = z
         "or a KEGG pathway ID ('hsa04010'). The prefix picks the database, so `vocabulary` and `organism` are ignored for it."),
     goId: z
         .string()
+        // oxlint-disable-next-line eslint-js/no-restricted-syntax -- the GO term id shape: the GO: prefix plus seven digits.
         .regex(/^GO:\d{7}$/)
         .optional()
         .describe("'go' only. A specific GO term ID, e.g. 'GO:0008150'."),
@@ -163,6 +164,8 @@ export const lookupAnnotationTool = defineTool({
                 const pathway = await getPathwayById(pathwayId);
                 return ok({ pathways: pathway ? [pathway] : [] });
             }
+            if (query === undefined)
+                throw new Error("the pathways lookup requires query");
             const pathways = await searchPathways(query, {
                 source: vocabulary === "pathways" ? "both" : vocabulary,
                 organism: organism ?? "hsa",

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

@@ -33,7 +33,7 @@ type OpenTargetsOutput = {
     candidates: DiseaseCandidate[];
 };
 export declare const openTargetsTool: import("../define-tool.js").Tool<{
-    action: "target" | "disease" | "resolve_disease";
+    action: "disease" | "resolve_disease" | "target";
     ensemblId?: string | undefined;
     efoId?: string | undefined;
     diseaseName?: string | undefined;

package/dist/tools/bio/opentargets.js

@@ -94,14 +94,20 @@ export const openTargetsTool = defineTool({
         const limit = input.limit ?? DEFAULT_LIMIT;
         switch (input.action) {
             case "target": {
+                if (input.ensemblId === undefined)
+                    throw new Error("target requires ensemblId");
                 const targetInfo = await searchTargetAssociations(input.ensemblId, limit);
                 return ok({ targetInfo, associations: targetInfo?.associations ?? [] });
             }
             case "disease": {
+                if (input.efoId === undefined)
+                    throw new Error("disease requires efoId");
                 const associations = await searchDiseaseAssociations(input.efoId, limit);
                 return ok({ associations });
             }
             case "resolve_disease": {
+                if (input.diseaseName === undefined)
+                    throw new Error("resolve_disease requires diseaseName");
                 const { total, candidates } = await searchDiseases(input.diseaseName, limit);
                 return ok({ totalFound: total, candidates });
             }

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

@@ -19,9 +19,9 @@ type PubchemOutput = {
     assays: PubChemAssay[];
 };
 export declare const pubchemTool: import("../define-tool.js").Tool<{
-    action: "compound" | "crossrefs" | "assays";
+    action: "assays" | "compound" | "crossrefs";
     query?: string | undefined;
-    searchBy?: "name" | "smiles" | "inchikey" | "inchi" | "cid" | undefined;
+    searchBy?: "cid" | "inchi" | "inchikey" | "name" | "smiles" | undefined;
     cid?: number | undefined;
     activeOnly?: boolean | undefined;
     limit?: number | undefined;

package/dist/tools/bio/pubchem.js

@@ -87,10 +87,16 @@ export const pubchemTool = defineTool({
     execute: async (input) => {
         switch (input.action) {
             case "compound":
+                if (input.query === undefined || input.searchBy === undefined)
+                    throw new Error("compound requires query and searchBy");
                 return ok({ results: await fetchPubchemCompounds(input.query, input.searchBy) });
             case "crossrefs":
+                if (input.cid === undefined)
+                    throw new Error("crossrefs requires cid");
                 return ok({ crossRefs: await fetchPubchemCrossRefs(input.cid) });
             case "assays":
+                if (input.cid === undefined)
+                    throw new Error("assays requires cid");
                 return ok({
                     assays: await fetchPubchemAssays(input.cid, {
                         activeOnly: input.activeOnly ?? true,

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

@@ -24,7 +24,32 @@
  * sections up to a character budget and always returns the article's full
  * section outline so a follow-up can name what it wants.
  */
+import { z } from "zod";
+import { type Tool } from "../define-tool.js";
 import { type BoundedArticleDetail, type BoundedFullText, type PubMedSummary } from "../lib/pubmed-client.js";
+declare const inputSchema: z.ZodObject<{
+    action: z.ZodEnum<{
+        details: "details";
+        fulltext: "fulltext";
+        search: "search";
+    }>;
+    query: z.ZodOptional<z.ZodString>;
+    maxResults: z.ZodOptional<z.ZodNumber>;
+    sort: z.ZodOptional<z.ZodEnum<{
+        date: "date";
+        relevance: "relevance";
+    }>>;
+    dateRange: z.ZodOptional<z.ZodObject<{
+        from: z.ZodString;
+        to: z.ZodString;
+    }, z.core.$strip>>;
+    pmids: z.ZodOptional<z.ZodArray<z.ZodString>>;
+    maxAuthors: z.ZodOptional<z.ZodNumber>;
+    maxMeshTerms: z.ZodOptional<z.ZodNumber>;
+    pmcId: z.ZodOptional<z.ZodString>;
+    sections: z.ZodOptional<z.ZodArray<z.ZodString>>;
+    maxChars: z.ZodOptional<z.ZodNumber>;
+}, z.core.$strip>;
 type PubMedOutput = {
     totalFound: number;
     results: PubMedSummary[];
@@ -40,20 +65,5 @@ type PubMedOutput = {
 } & Omit<BoundedFullText, "sections">);
 export declare function createPubMedTool(deps: {
     ncbiApiKey?: string;
-}): import("../define-tool.js").Tool<{
-    action: "search" | "details" | "fulltext";
-    query?: string | undefined;
-    maxResults?: number | undefined;
-    sort?: "date" | "relevance" | undefined;
-    dateRange?: {
-        from: string;
-        to: string;
-    } | undefined;
-    pmids?: string[] | undefined;
-    maxAuthors?: number | undefined;
-    maxMeshTerms?: number | undefined;
-    pmcId?: string | undefined;
-    sections?: string[] | undefined;
-    maxChars?: number | undefined;
-}, PubMedOutput>;
+}): Tool<z.infer<typeof inputSchema>, PubMedOutput>;
 export {};

package/dist/tools/bio/pubmed.js

@@ -150,12 +150,16 @@ export function createPubMedTool(deps) {
         execute: async (input, context) => {
             switch (input.action) {
                 case "search":
+                    if (input.query === undefined)
+                        throw new Error("search requires query");
                     return ok(await searchPubmed(deps.ncbiApiKey, input.query, {
                         maxResults: input.maxResults ?? DEFAULTS.searchResults,
-                        ...(input.sort ? { sort: input.sort } : {}),
-                        ...(input.dateRange ? { dateRange: input.dateRange } : {}),
+                        sort: input.sort,
+                        dateRange: input.dateRange,
                     }, context.signal));
                 case "details": {
+                    if (input.pmids === undefined)
+                        throw new Error("details requires pmids");
                     const { articles, notFound } = await getArticleDetails(deps.ncbiApiKey, input.pmids, context.signal);
                     return ok({
                         articles: boundArticleDetails(articles, {
@@ -166,8 +170,10 @@ export function createPubMedTool(deps) {
                     });
                 }
                 case "fulltext": {
+                    if (input.pmcId === undefined)
+                        throw new Error("fulltext requires pmcId");
                     const parsed = await getArticleFullText(deps.ncbiApiKey, input.pmcId, {
-                        ...(input.sections ? { sections: input.sections } : {}),
+                        sections: input.sections ? input.sections : undefined,
                         maxChars: input.maxChars ?? DEFAULTS.maxChars,
                     }, context.signal);
                     // "Not open-access" is an expected outcome — a data variant, not an error.

package/dist/tools/bio/search-clinical-trials.d.ts

@@ -20,12 +20,12 @@ type ClinicalTrialsOutput = {
     trials: TrialListRow[];
 };
 export declare const searchClinicalTrialsTool: import("../define-tool.js").Tool<{
-    action: "search" | "details";
-    limit: number;
-    includeSummaries: boolean;
+    action: "details" | "search";
     query?: string | undefined;
     nctId?: string | undefined;
     phase?: "EARLY_PHASE1" | "PHASE1" | "PHASE2" | "PHASE3" | "PHASE4" | undefined;
-    status?: "SUSPENDED" | "RECRUITING" | "ACTIVE_NOT_RECRUITING" | "COMPLETED" | "NOT_YET_RECRUITING" | "TERMINATED" | "WITHDRAWN" | undefined;
+    status?: "ACTIVE_NOT_RECRUITING" | "COMPLETED" | "NOT_YET_RECRUITING" | "RECRUITING" | "SUSPENDED" | "TERMINATED" | "WITHDRAWN" | undefined;
+    limit: number;
+    includeSummaries: boolean;
 }, ClinicalTrialsOutput>;
 export {};

package/dist/tools/bio/search-clinical-trials.js

@@ -77,10 +77,14 @@ export const searchClinicalTrialsTool = defineTool({
         path: ["nctId"],
     }),
     describeCall: "none",
-    execute: async ({ action = "search", query, nctId, phase, status, limit = 10, includeSummaries = false, }) => {
+    execute: async ({ action, query, nctId, phase, status, limit, includeSummaries }) => {
         if (action === "details") {
+            if (nctId === undefined)
+                throw new Error("details requires nctId");
             return ok({ trial: await getTrialDetails(nctId) });
         }
+        if (query === undefined)
+            throw new Error("search requires query");
         const result = await searchTrials(query, { phase, status, limit });
         const trials = includeSummaries
             ? result.trials

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

@@ -23,9 +23,9 @@ type FaersOutput = {
     labels: DrugLabelAction[];
 };
 export declare const searchFaersTool: import("../define-tool.js").Tool<{
-    action: "label" | "adverse_events" | "seriousness";
+    action: "adverse_events" | "label" | "seriousness";
     drugName: string;
-    serious: boolean;
     limit?: number | undefined;
+    serious: boolean;
 }, FaersOutput>;
 export {};

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

@@ -71,7 +71,7 @@ export const searchFaersTool = defineTool({
         path: ["limit"],
     }),
     describeCall: "none",
-    execute: async ({ action = "adverse_events", drugName, limit, serious = false }) => {
+    execute: async ({ action, drugName, limit, serious }) => {
         switch (action) {
             case "seriousness":
                 return ok({ seriousness: await getFaersSeriousness(drugName) });

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

@@ -11,10 +11,10 @@
  */
 import { type GeneInfo } from "../lib/ensembl-client.js";
 /** One input that was not a symbol, beside the approved symbol it became. */
-interface ResolvedIdentifier {
+type ResolvedIdentifier = {
     input: string;
     symbol: string;
-}
+};
 export declare const searchGeneTool: import("../define-tool.js").Tool<{
     identifiers: string[];
     species: string;

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

@@ -24,6 +24,7 @@ const IDENTIFIERS_LISTED_IN_FULL = 8;
  * The identifier spaces that Ensembl cannot key on. Anything that matches none
  * of them is treated as a symbol and goes straight to Ensembl.
  */
+// oxlint-disable-next-line eslint-js/no-restricted-syntax -- each entry is the fixed issued shape of one identifier space (Ensembl, HGNC, ChEMBL, UniProt); the alternation of the four is what keys the resolver.
 const NON_SYMBOL_PATTERNS = [/^ENSG\d{11}$/, /^HGNC:\d+$/, /^CHEMBL\d+$/, /^[A-Z][0-9][A-Z0-9]{3}[0-9](-\d+)?$/];
 function isSymbol(identifier) {
     return !NON_SYMBOL_PATTERNS.some((pattern) => pattern.test(identifier));

package/dist/tools/bio/search-geo-datasets.d.ts

@@ -9,7 +9,7 @@ export declare const GeoEsearchResponseSchema: z.ZodObject<{
     }, z.core.$strip>>;
 }, z.core.$strip>;
 /** One dataset row, as the tool returns it. */
-export interface GeoDataset {
+export type GeoDataset = {
     accession: string;
     title: string;
     summary: string;
@@ -17,7 +17,7 @@ export interface GeoDataset {
     sampleCount: number | null;
     organism: string | null;
     pubmedIds: (string | number)[];
-}
+};
 export declare const GeoEsummaryResponseSchema: z.ZodObject<{
     result: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodCatch<z.ZodOptional<z.ZodObject<{
         accession: z.ZodOptional<z.ZodString>;
@@ -41,9 +41,9 @@ export declare const GeoEsummaryResponseSchema: z.ZodObject<{
 export declare function mapGeoDatasets(ids: string[], summary: z.infer<typeof GeoEsummaryResponseSchema>): GeoDataset[];
 export declare const searchGeoDatasetsTool: import("../define-tool.js").Tool<{
     query: string;
-    datasetType: "gse" | "gds";
-    limit: number;
     organism?: string | undefined;
+    datasetType: "gds" | "gse";
+    limit: number;
 }, {
     totalFound: number;
     datasets: GeoDataset[];

package/dist/tools/bio/search-geo-datasets.js

@@ -48,7 +48,7 @@ export const GeoEsummaryResponseSchema = z.object({
  * payload.
  */
 export function mapGeoDatasets(ids, summary) {
-    const result = summary?.result ?? {};
+    const result = summary.result ?? {};
     const datasets = [];
     for (const id of ids) {
         const r = result[id];
@@ -101,13 +101,13 @@ export const searchGeoDatasetsTool = defineTool({
             .describe("Max datasets to return (default 10, max 50). totalFound reports the true match count regardless."),
     }),
     describeCall: "none",
-    execute: async ({ query, organism, datasetType = "gse", limit = 10 }) => {
+    execute: async ({ query, organism, datasetType, limit }) => {
         let searchQuery = query;
         // Escape backslashes first, then quotes, so a `\` in the organism value
         // cannot smuggle an unescaped `"` past the escaping and break out of the
         // quoted Entrez phrase.
         if (organism)
-            searchQuery += ` AND "${organism.replace(/\\/g, "\\\\").replace(/"/g, '\\"')}"[Organism]`;
+            searchQuery += ` AND "${organism.replaceAll("\\", "\\\\").replaceAll('"', '\\"')}"[Organism]`;
         const db = "gds";
         const typeFilter = datasetType === "gse" ? " AND gse[Entry Type]" : " AND gds[Entry Type]";
         searchQuery += typeFilter;
@@ -115,7 +115,7 @@ export const searchGeoDatasetsTool = defineTool({
         const searchRes = await apiFetchValidated(searchUrl, GeoEsearchResponseSchema);
         if (searchRes.isErr())
             throw new Error(describeApiError(searchRes.error));
-        const ids = searchRes.value?.esearchresult?.idlist ?? [];
+        const ids = searchRes.value.esearchresult?.idlist ?? [];
         if (ids.length === 0)
             return ok({ totalFound: 0, datasets: [] });
         const summaryUrl = `${ESEARCH_BASE}/esummary.fcgi?db=${db}&id=${ids.join(",")}&retmode=json`;
@@ -123,7 +123,7 @@ export const searchGeoDatasetsTool = defineTool({
         if (summaryRes.isErr())
             throw new Error(describeApiError(summaryRes.error));
         const datasets = mapGeoDatasets(ids, summaryRes.value);
-        const totalFound = Number(searchRes.value?.esearchresult?.count) || datasets.length;
+        const totalFound = Number(searchRes.value.esearchresult?.count) || datasets.length;
         return ok({ totalFound, datasets });
     },
 });

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

@@ -14,7 +14,7 @@ type InteractionsOutput = {
 export declare const searchInteractionsTool: import("../define-tool.js").Tool<{
     identifiers: string[];
     species: number;
-    action: "enrichment" | "partners" | "network";
+    action: "enrichment" | "network" | "partners";
     minScore: number;
     limit: number;
 }, InteractionsOutput>;