@inflexa-ai/harness 0.1.1

package/dist/tools/bio/search-ctx-exposure.js

@@ -0,0 +1,176 @@
+/**
+ * searchCtxExposure — look up chemical exposure data from EPA's CTX
+ * Exposure APIs.
+ */
+import { ok } from "neverthrow";
+import { z } from "zod";
+import { defineTool } from "../define-tool.js";
+import { apiFetchValidated, describeApiError } from "../lib/api-utils.js";
+import { EPA_CCTE_BASE, getEpaCcteHeaders } from "../lib/toxcast-config.js";
+// The chemical-search endpoint returns rows the code reads `[0].dtxsid` from
+// after a length guard, so `dtxsid` stays required — a row missing it is a
+// contract break surfaced as `invalid_response`, not a silent `undefined`.
+const CtxChemicalSearchRowSchema = z.object({
+    dtxsid: z.string(),
+});
+// SEEM exposure-prediction wire shape (endpoint returns a single object or an
+// array). `probabilityPesticde` is the API's own misspelling, read as a
+// fallback before the corrected `probabilityPesticide`, so both stay modeled.
+const RawSeemPredictionSchema = z.object({
+    dtxsid: z.string().optional(),
+    productionVolume: z.number().nullable().optional(),
+    units: z.string().nullable().optional(),
+    probabilityDietary: z.number().nullable().optional(),
+    probabilityResidential: z.number().nullable().optional(),
+    probabilityPesticde: z.number().nullable().optional(),
+    probabilityPesticide: z.number().nullable().optional(),
+    probabilityIndustrial: z.number().nullable().optional(),
+});
+const RawHttkRowSchema = z.object({
+    parameter: z.string().nullable().optional(),
+    measured: z.number().nullable().optional(),
+    predicted: z.number().nullable().optional(),
+    units: z.string().nullable().optional(),
+    model: z.string().nullable().optional(),
+    species: z.string().nullable().optional(),
+    reference: z.string().nullable().optional(),
+});
+const RawFunctionalUseRowSchema = z.object({
+    functioncategory: z.string().nullable().optional(),
+    reportedfunction: z.string().nullable().optional(),
+    doctitle: z.string().nullable().optional(),
+});
+const RawProductDataRowSchema = z.object({
+    productname: z.string().nullable().optional(),
+    gencat: z.string().nullable().optional(),
+    prodfam: z.string().nullable().optional(),
+    prodtype: z.string().nullable().optional(),
+    centralweightfraction: z.number().nullable().optional(),
+    weightfractiontype: z.string().nullable().optional(),
+});
+export function createSearchCtxExposureTool(deps) {
+    return defineTool({
+        id: "search_ctx_exposure",
+        description: "Look up chemical exposure data from EPA's CTX Exposure APIs. Returns: " +
+            "SEEM general exposure predictions (estimated daily intake, exposure pathway probabilities), " +
+            "HTTK toxicokinetic parameters (Css, clearance, volume of distribution, protein binding), " +
+            "functional use categories, and product composition data. " +
+            "Use for exposure-based safety margin calculations (comparing ToxCast bioactivity AC50 " +
+            "against predicted human exposure), IVIVE context, and exposure pathway characterization. " +
+            "Requires EPA_CCTE_API_KEY environment variable.",
+        inputSchema: z.object({
+            query: z.string().describe("Chemical identifier: DTXSID (e.g. DTXSID7020182), CASRN (e.g. 80-05-7), " + "or chemical name (e.g. bisphenol A)"),
+            dataType: z
+                .enum(["seem", "httk", "functional-use", "product-data", "all"])
+                .default("all")
+                .describe("'seem' for SEEM exposure predictions, " +
+                "'httk' for toxicokinetic parameters, " +
+                "'functional-use' for chemical use categories, " +
+                "'product-data' for consumer product composition, " +
+                "'all' for combined results"),
+            limit: z.number().int().min(1).max(100).default(25).describe("Max results per category (for functional-use and product-data)"),
+        }),
+        execute: async ({ query, dataType = "all", limit = 25 }) => {
+            const headers = getEpaCcteHeaders(deps.apiKey);
+            const resolved = await resolveDtxsid(query, headers);
+            // "No chemical found" is an expected outcome — a data variant, not an error.
+            if (!resolved)
+                return ok({ found: false, query });
+            const { dtxsid } = resolved;
+            const result = { found: true, dtxsid };
+            const fetchers = [];
+            if (dataType === "seem" || dataType === "all") {
+                fetchers.push(fetchSeem(dtxsid, headers).then((v) => {
+                    result.seem = v;
+                }));
+            }
+            if (dataType === "httk" || dataType === "all") {
+                fetchers.push(fetchHttk(dtxsid, headers).then((v) => {
+                    result.httk = v;
+                }));
+            }
+            if (dataType === "functional-use" || dataType === "all") {
+                fetchers.push(fetchFunctionalUse(dtxsid, headers, limit).then((v) => {
+                    result.functionalUse = v;
+                }));
+            }
+            if (dataType === "product-data" || dataType === "all") {
+                fetchers.push(fetchProductData(dtxsid, headers, limit).then((v) => {
+                    result.productData = v;
+                }));
+            }
+            await Promise.all(fetchers);
+            return ok(result);
+        },
+    });
+}
+async function resolveDtxsid(query, headers) {
+    if (query.startsWith("DTXSID")) {
+        return { dtxsid: query };
+    }
+    const url = `${EPA_CCTE_BASE}/chemical/search/equal/${encodeURIComponent(query)}`;
+    const res = await apiFetchValidated(url, z.array(CtxChemicalSearchRowSchema), { headers });
+    if (res.isErr())
+        throw new Error(describeApiError(res.error));
+    if (!res.value?.length)
+        return null;
+    return { dtxsid: res.value[0].dtxsid };
+}
+async function fetchSeem(dtxsid, headers) {
+    const url = `${EPA_CCTE_BASE}/exposure/seem/general/search/by-dtxsid/${dtxsid}`;
+    const res = await apiFetchValidated(url, z.union([RawSeemPredictionSchema, z.array(RawSeemPredictionSchema)]), { headers });
+    if (res.isErr() || !res.value)
+        return undefined;
+    const d = Array.isArray(res.value) ? res.value[0] : res.value;
+    if (!d)
+        return undefined;
+    return {
+        dtxsid: d.dtxsid ?? dtxsid,
+        productionVolume: d.productionVolume ?? null,
+        units: d.units ?? "",
+        probabilityDietary: d.probabilityDietary ?? null,
+        probabilityResidential: d.probabilityResidential ?? null,
+        probabilityPesticide: d.probabilityPesticde ?? d.probabilityPesticide ?? null,
+        probabilityIndustrial: d.probabilityIndustrial ?? null,
+    };
+}
+async function fetchHttk(dtxsid, headers) {
+    const url = `${EPA_CCTE_BASE}/exposure/httk/search/by-dtxsid/${dtxsid}`;
+    const res = await apiFetchValidated(url, z.array(RawHttkRowSchema), { headers });
+    if (res.isErr() || !Array.isArray(res.value))
+        return [];
+    return res.value.map((r) => ({
+        parameter: r.parameter ?? "",
+        measured: r.measured ?? null,
+        predicted: r.predicted ?? null,
+        units: r.units ?? "",
+        model: r.model ?? "",
+        species: r.species ?? "",
+        reference: r.reference ?? "",
+    }));
+}
+async function fetchFunctionalUse(dtxsid, headers, limit) {
+    const url = `${EPA_CCTE_BASE}/exposure/functional-use/search/by-dtxsid/${dtxsid}`;
+    const res = await apiFetchValidated(url, z.array(RawFunctionalUseRowSchema), { headers });
+    if (res.isErr() || !Array.isArray(res.value))
+        return [];
+    return res.value.slice(0, limit).map((r) => ({
+        functionCategory: r.functioncategory ?? "",
+        reportedFunction: r.reportedfunction ?? "",
+        docTitle: r.doctitle ?? "",
+    }));
+}
+async function fetchProductData(dtxsid, headers, limit) {
+    const url = `${EPA_CCTE_BASE}/exposure/product-data/search/by-dtxsid/${dtxsid}`;
+    const res = await apiFetchValidated(url, z.array(RawProductDataRowSchema), { headers });
+    if (res.isErr() || !Array.isArray(res.value))
+        return [];
+    return res.value.slice(0, limit).map((r) => ({
+        productName: r.productname ?? "",
+        generalCategory: r.gencat ?? "",
+        productFamily: r.prodfam ?? "",
+        productType: r.prodtype ?? "",
+        centralWeightFraction: r.centralweightfraction ?? null,
+        weightFractionType: r.weightfractiontype ?? "",
+    }));
+}

package/dist/tools/bio/search-ctx-hazard.d.ts

@@ -0,0 +1,111 @@
+/**
+ * searchCtxHazard — search EPA CTX Hazard APIs (ToxValDB, ToxRefDB) for
+ * toxicological hazard data on a chemical.
+ */
+import { z } from "zod";
+declare const ToxValSchema: z.ZodPipe<z.ZodObject<{
+    source: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+    toxvalType: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+    toxvalNumeric: z.ZodOptional<z.ZodUnknown>;
+    toxvalUnits: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+    studyType: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+    studyDurationClass: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+    speciesCommon: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+    exposureRoute: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+    toxicologicalEffect: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+    riskAssessmentClass: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+    humanEco: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+    year: z.ZodOptional<z.ZodUnknown>;
+    quality: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+}, z.core.$strip>, z.ZodTransform<{
+    source: string;
+    toxvalType: string;
+    toxvalNumeric: number | null;
+    toxvalUnits: string;
+    studyType: string;
+    studyDurationClass: string;
+    species: string;
+    exposureRoute: string;
+    toxicologicalEffect: string;
+    riskAssessmentClass: string;
+    humanEco: string;
+    year: number | null;
+    quality: string;
+}, {
+    source?: string | null | undefined;
+    toxvalType?: string | null | undefined;
+    toxvalNumeric?: unknown;
+    toxvalUnits?: string | null | undefined;
+    studyType?: string | null | undefined;
+    studyDurationClass?: string | null | undefined;
+    speciesCommon?: string | null | undefined;
+    exposureRoute?: string | null | undefined;
+    toxicologicalEffect?: string | null | undefined;
+    riskAssessmentClass?: string | null | undefined;
+    humanEco?: string | null | undefined;
+    year?: unknown;
+    quality?: string | null | undefined;
+}>>;
+type ToxValEntry = z.infer<typeof ToxValSchema>;
+declare const GenetoxSchema: z.ZodPipe<z.ZodObject<{
+    source: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+    assayCategory: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+    assayType: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+    metabolicActivation: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+    species: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+    overallResult: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+    year: z.ZodOptional<z.ZodUnknown>;
+}, z.core.$strip>, z.ZodTransform<{
+    source: string;
+    assayCategory: string;
+    assayType: string;
+    metabolicActivation: string;
+    species: string;
+    overallResult: string;
+    year: number | null;
+}, {
+    source?: string | null | undefined;
+    assayCategory?: string | null | undefined;
+    assayType?: string | null | undefined;
+    metabolicActivation?: string | null | undefined;
+    species?: string | null | undefined;
+    overallResult?: string | null | undefined;
+    year?: unknown;
+}>>;
+type GenetoxSummary = z.infer<typeof GenetoxSchema>;
+declare const CancerSchema: z.ZodPipe<z.ZodObject<{
+    source: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+    classification: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+    cancerClassification: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+    url: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+}, z.core.$strip>, z.ZodTransform<{
+    source: string;
+    classification: string;
+    url: string;
+}, {
+    source?: string | null | undefined;
+    classification?: string | null | undefined;
+    cancerClassification?: string | null | undefined;
+    url?: string | null | undefined;
+}>>;
+type CancerSummary = z.infer<typeof CancerSchema>;
+interface CtxHazardOutput {
+    found: true;
+    dtxsid: string;
+    preferredName: string;
+    toxval?: ToxValEntry[];
+    genetox?: GenetoxSummary[];
+    cancer?: CancerSummary[];
+}
+type CtxHazardResult = {
+    found: false;
+    query: string;
+} | CtxHazardOutput;
+export declare function createSearchCtxHazardTool(deps: {
+    apiKey: string;
+}): import("../define-tool.js").Tool<{
+    query: string;
+    dataType: "toxval" | "genetox" | "cancer" | "all";
+    limit: number;
+}, CtxHazardResult>;
+export {};

package/dist/tools/bio/search-ctx-hazard.js

@@ -0,0 +1,178 @@
+/**
+ * searchCtxHazard — search EPA CTX Hazard APIs (ToxValDB, ToxRefDB) for
+ * toxicological hazard data on a chemical.
+ */
+import { ok } from "neverthrow";
+import { z } from "zod";
+import { defineTool } from "../define-tool.js";
+import { apiFetchValidated, describeApiError } from "../lib/api-utils.js";
+import { EPA_CCTE_BASE, getEpaCcteHeaders } from "../lib/toxcast-config.js";
+// Each schema below both validates one raw CTX hazard row and normalizes it
+// into the curated output shape via `.transform`; `z.infer` is that output
+// type. Every wire field is optional (the API omits absent values); the two
+// numeric fields the API sends as string-or-number stay `z.unknown()` so
+// `toNumberOrNull` can coerce them without the schema rejecting the row.
+const ToxValSchema = z
+    .object({
+    source: z.string().nullable().optional(),
+    toxvalType: z.string().nullable().optional(),
+    toxvalNumeric: z.unknown().optional(),
+    toxvalUnits: z.string().nullable().optional(),
+    studyType: z.string().nullable().optional(),
+    studyDurationClass: z.string().nullable().optional(),
+    speciesCommon: z.string().nullable().optional(),
+    exposureRoute: z.string().nullable().optional(),
+    toxicologicalEffect: z.string().nullable().optional(),
+    riskAssessmentClass: z.string().nullable().optional(),
+    humanEco: z.string().nullable().optional(),
+    year: z.unknown().optional(),
+    quality: z.string().nullable().optional(),
+})
+    .transform((r) => ({
+    source: r.source ?? "",
+    toxvalType: r.toxvalType ?? "",
+    toxvalNumeric: toNumberOrNull(r.toxvalNumeric),
+    toxvalUnits: r.toxvalUnits ?? "",
+    studyType: r.studyType ?? "",
+    studyDurationClass: r.studyDurationClass ?? "",
+    species: r.speciesCommon ?? "",
+    exposureRoute: r.exposureRoute ?? "",
+    toxicologicalEffect: r.toxicologicalEffect ?? "",
+    riskAssessmentClass: r.riskAssessmentClass ?? "",
+    humanEco: r.humanEco ?? "",
+    year: toNumberOrNull(r.year),
+    quality: r.quality ?? "",
+}));
+const GenetoxSchema = z
+    .object({
+    source: z.string().nullable().optional(),
+    assayCategory: z.string().nullable().optional(),
+    assayType: z.string().nullable().optional(),
+    metabolicActivation: z.string().nullable().optional(),
+    species: z.string().nullable().optional(),
+    overallResult: z.string().nullable().optional(),
+    year: z.unknown().optional(),
+})
+    .transform((r) => ({
+    source: r.source ?? "",
+    assayCategory: r.assayCategory ?? "",
+    assayType: r.assayType ?? "",
+    metabolicActivation: r.metabolicActivation ?? "",
+    species: r.species ?? "",
+    overallResult: r.overallResult ?? "",
+    year: toNumberOrNull(r.year),
+}));
+const CancerSchema = z
+    .object({
+    source: z.string().nullable().optional(),
+    classification: z.string().nullable().optional(),
+    cancerClassification: z.string().nullable().optional(),
+    url: z.string().nullable().optional(),
+})
+    .transform((r) => ({
+    source: r.source ?? "",
+    classification: r.classification ?? r.cancerClassification ?? "",
+    url: r.url ?? "",
+}));
+// The chemical-search endpoint returns rows the code reads `dtxsid` from
+// unguarded, so `dtxsid` stays required — a row missing it is a contract break
+// surfaced as `invalid_response`, not a silent `undefined`.
+const CtxChemicalSearchRowSchema = z.object({
+    dtxsid: z.string(),
+    preferredName: z.string().nullable().optional(),
+});
+export function createSearchCtxHazardTool(deps) {
+    return defineTool({
+        id: "search_ctx_hazard",
+        description: "Search EPA CTX Hazard APIs (ToxValDB, ToxRefDB) for toxicological hazard data on a chemical. " +
+            "Returns in-vivo toxicity values (NOAELs, LOAELs, LD50s, BMDs), " +
+            "genetox summaries, and cancer classifications. " +
+            "Use to assess toxicological hazard profile for safety evaluation. " +
+            "Requires EPA_CCTE_API_KEY environment variable.",
+        inputSchema: z.object({
+            query: z.string().describe("Chemical identifier: DTXSID (e.g. DTXSID7020182), CASRN (e.g. 80-05-7), " + "or chemical name (e.g. bisphenol A)"),
+            dataType: z
+                .enum(["toxval", "genetox", "cancer", "all"])
+                .default("all")
+                .describe("'toxval' for ToxValDB dose-response data (NOAELs, LOAELs, LD50s), " +
+                "'genetox' for genotoxicity summaries, " +
+                "'cancer' for cancer classifications, " +
+                "'all' for combined results"),
+            limit: z.number().int().min(1).max(100).default(30).describe("Max results per category"),
+        }),
+        execute: async ({ query, dataType = "all", limit = 30 }) => {
+            const headers = getEpaCcteHeaders(deps.apiKey);
+            const resolved = await resolveDtxsid(query, headers);
+            // "No chemical found" is an expected outcome — a data variant, not an error.
+            if (!resolved)
+                return ok({ found: false, query });
+            const { dtxsid, preferredName } = resolved;
+            const result = {
+                found: true,
+                dtxsid,
+                preferredName,
+            };
+            const fetchers = [];
+            if (dataType === "toxval" || dataType === "all") {
+                fetchers.push(fetchToxval(dtxsid, headers, limit).then((v) => {
+                    result.toxval = v;
+                }));
+            }
+            if (dataType === "genetox" || dataType === "all") {
+                fetchers.push(fetchGenetox(dtxsid, headers, limit).then((v) => {
+                    result.genetox = v;
+                }));
+            }
+            if (dataType === "cancer" || dataType === "all") {
+                fetchers.push(fetchCancer(dtxsid, headers).then((v) => {
+                    result.cancer = v;
+                }));
+            }
+            await Promise.all(fetchers);
+            return ok(result);
+        },
+    });
+}
+async function resolveDtxsid(query, headers) {
+    if (query.startsWith("DTXSID")) {
+        return { dtxsid: query, preferredName: query };
+    }
+    const url = `${EPA_CCTE_BASE}/chemical/search/equal/${encodeURIComponent(query)}`;
+    const res = await apiFetchValidated(url, z.array(CtxChemicalSearchRowSchema), { headers });
+    if (res.isErr())
+        throw new Error(describeApiError(res.error));
+    if (!res.value?.length)
+        return null;
+    const chem = res.value[0];
+    return {
+        dtxsid: chem.dtxsid,
+        preferredName: chem.preferredName ?? query,
+    };
+}
+async function fetchToxval(dtxsid, headers, limit) {
+    const url = `${EPA_CCTE_BASE}/hazard/toxval/search/by-dtxsid/${dtxsid}`;
+    const res = await apiFetchValidated(url, z.array(ToxValSchema), { headers });
+    if (res.isErr() || !Array.isArray(res.value))
+        return [];
+    return res.value.slice(0, limit);
+}
+function toNumberOrNull(v) {
+    if (v == null || v === "")
+        return null;
+    const n = typeof v === "number" ? v : Number(v);
+    return Number.isFinite(n) ? n : null;
+}
+async function fetchGenetox(dtxsid, headers, limit) {
+    const url = `${EPA_CCTE_BASE}/hazard/genetox/summary/search/by-dtxsid/${dtxsid}`;
+    const res = await apiFetchValidated(url, z.array(GenetoxSchema), { headers });
+    if (res.isErr() || !Array.isArray(res.value))
+        return [];
+    return res.value.slice(0, limit);
+}
+async function fetchCancer(dtxsid, headers) {
+    const url = `${EPA_CCTE_BASE}/hazard/cancer-summary/search/by-dtxsid/${dtxsid}`;
+    const res = await apiFetchValidated(url, z.array(CancerSchema), { headers });
+    if (res.isErr() || !Array.isArray(res.value))
+        return [];
+    return res.value;
+}

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

@@ -0,0 +1,43 @@
+/**
+ * searchDgidb tool — query drug-gene interactions via DGIdb GraphQL.
+ *
+ * DGIdb aggregates interactions from 30+ sources (ChEMBL, DrugBank, TTD,
+ * PharmGKB, GuideToPharmacology, CIViC, etc.). Free, no API key required.
+ *
+ * Two directions:
+ *   - searchType="gene": input HUGO symbols, returns drugs interacting with each.
+ *   - searchType="drug": input drug names/concept IDs, returns genes each acts on.
+ */
+interface Interaction {
+    geneName: string;
+    drugName: string;
+    drugConceptId?: string;
+    interactionTypes: {
+        type: string;
+        directionality?: string;
+    }[];
+    interactionScore?: number;
+    sourceCount: number;
+    sources: string[];
+    publicationCount: number;
+    pmids: string[];
+    attributes: {
+        name: string;
+        value: string;
+    }[];
+}
+export declare const searchDgidbTool: import("../define-tool.js").Tool<{
+    query: string | string[];
+    searchType: "drug" | "gene";
+    minSources: number;
+    limit: number;
+    interactionTypes?: string[] | undefined;
+    sources?: string[] | undefined;
+}, {
+    results: {
+        input: string;
+        found: boolean;
+        interactions: Interaction[];
+    }[];
+}>;
+export {};