@inflexa-ai/harness 0.12.0 → 0.14.0

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

@@ -1,109 +0,0 @@
-/**
- * searchDrugbank — search DrugBank for drug records and target-driven lookups.
- *
- * Requires `DRUGBANK_API_KEY`. Without the key, `getDrugbankHeaders` throws
- * on first call; the harness surfaces that as a tool `is_error` envelope.
- */
-import { ok } from "neverthrow";
-import { z } from "zod";
-import { defineTool } from "../define-tool.js";
-import { apiFetchValidated, describeApiError } from "../lib/api-utils.js";
-import { DRUGBANK_BASE, getDrugbankHeaders } from "../lib/drugbank-config.js";
-// A single schema that both validates and normalizes one DrugBank record.
-// The `.object(...)` half is the snake_case wire shape (every field optional —
-// the API omits absent values); the `.transform(...)` half maps it into the
-// camelCase result we return. Parsing IS the validation: `apiFetchValidated`
-// runs this schema over the JSON, so a payload whose field TYPES drift (an
-// object where the API used to send an array, a number for a string) is
-// rejected as `invalid_response` instead of being silently mis-mapped. Because
-// the schema carries the transform, `z.infer` below is the OUTPUT (camelCase)
-// type callers receive — there is no separate raw interface or mapper to keep
-// in sync.
-const DrugResultSchema = z
-    .object({
-    drugbank_id: z.string().optional(),
-    name: z.string().optional(),
-    description: z.string().optional(),
-    type: z.string().optional(),
-    groups: z.array(z.string()).optional(),
-    categories: z.array(z.object({ category: z.string().optional() })).optional(),
-    indication: z.string().optional(),
-    pharmacodynamics: z.string().optional(),
-    mechanism_of_action: z.string().optional(),
-    toxicity: z.string().optional(),
-    half_life: z.string().optional(),
-    targets: z
-        .array(z.object({
-        name: z.string().optional(),
-        gene_name: z.string().optional(),
-        actions: z.array(z.string()).optional(),
-        known_action: z.string().optional(),
-    }))
-        .optional(),
-    drug_interactions: z
-        .array(z.object({
-        drugbank_id: z.string().optional(),
-        name: z.string().optional(),
-        description: z.string().optional(),
-    }))
-        .optional(),
-})
-    .transform((raw) => ({
-    drugbankId: raw.drugbank_id ?? "",
-    name: raw.name ?? "",
-    description: (raw.description ?? "").slice(0, 500),
-    type: raw.type ?? "",
-    groups: raw.groups ?? [],
-    categories: (raw.categories ?? []).map((c) => c.category ?? "").filter(Boolean),
-    indication: (raw.indication ?? "").slice(0, 500),
-    pharmacodynamics: (raw.pharmacodynamics ?? "").slice(0, 500),
-    mechanismOfAction: (raw.mechanism_of_action ?? "").slice(0, 500),
-    toxicity: (raw.toxicity ?? "").slice(0, 500),
-    halfLife: raw.half_life ?? "",
-    targets: (raw.targets ?? []).slice(0, 20).map((t) => ({
-        name: t.name ?? "",
-        geneSymbol: t.gene_name ?? "",
-        actions: t.actions ?? [],
-        knownAction: t.known_action ?? "",
-    })),
-    interactions: (raw.drug_interactions ?? []).slice(0, 20).map((i) => ({
-        drugbankId: i.drugbank_id ?? "",
-        name: i.name ?? "",
-        description: (i.description ?? "").slice(0, 200),
-    })),
-}));
-// The /drugs endpoint returns a single object (by-id lookup) or an array
-// (query/target lookups); accept either, transforming each element.
-const DrugResponseSchema = z.union([DrugResultSchema, z.array(DrugResultSchema)]);
-export function createSearchDrugbankTool(deps) {
-    return defineTool({
-        id: "search_drugbank",
-        description: "Search DrugBank for drug information including targets, interactions, indications, " +
-            "pharmacodynamics, and toxicity. Requires DRUGBANK_API_KEY. Use for drug repurposing " +
-            "analysis, drug-drug interaction assessment, and connecting omics targets to existing therapeutics.",
-        inputSchema: z.object({
-            query: z.string().describe("Drug name (e.g. imatinib), DrugBank ID (e.g. DB00619), or target gene symbol for reverse lookup"),
-            searchType: z.enum(["drug", "target"]).default("drug").describe("'drug' to search by drug name/ID, 'target' to find drugs for a gene target"),
-            limit: z.number().int().min(1).max(50).default(10).describe("Max results to return"),
-        }),
-        execute: async ({ query, searchType = "drug", limit = 10 }) => {
-            const headers = getDrugbankHeaders(deps.apiKey);
-            let url;
-            if (searchType === "target") {
-                url = `${DRUGBANK_BASE}/drugs?target=${encodeURIComponent(query)}&limit=${limit}`;
-            }
-            else if (query.startsWith("DB")) {
-                url = `${DRUGBANK_BASE}/drugs/${query}`;
-            }
-            else {
-                url = `${DRUGBANK_BASE}/drugs?q=${encodeURIComponent(query)}&limit=${limit}`;
-            }
-            const res = await apiFetchValidated(url, DrugResponseSchema, { headers });
-            if (res.isErr())
-                throw new Error(describeApiError(res.error));
-            // Already validated + normalized by DrugResultSchema's transform.
-            const drugs = Array.isArray(res.value) ? res.value : [res.value];
-            return ok({ drugs: drugs.slice(0, limit) });
-        },
-    });
-}

package/dist/tools/bio/search-gwas-catalog.d.ts

@@ -1,33 +0,0 @@
-/**
- * searchGwasCatalog — search NHGRI-EBI GWAS Catalog for SNP-trait associations.
- *
- * Public REST API, no key required. Three search modes:
- *   - 'gene' — gene-trait associations (via SNP-by-gene lookup, then assocs)
- *   - 'trait' — trait-gene associations (via EFO trait search, then assocs)
- *   - 'variant' — direct rsID lookup
- */
-interface GwasAssociation {
-    rsId: string;
-    pValue: number;
-    pValueMantissa: number;
-    pValueExponent: number;
-    riskAllele: string;
-    riskFrequency: string;
-    orBeta: number | null;
-    ci: string;
-    trait: string;
-    mappedGenes: string[];
-    studyAccession: string;
-    pubmedId: string;
-    sampleSize: string;
-}
-export declare const searchGwasCatalogTool: import("../define-tool.js").Tool<{
-    query: string;
-    searchType: "gene" | "variant" | "trait";
-    pValueThreshold: number;
-    limit: number;
-}, {
-    totalFound: number;
-    associations: GwasAssociation[];
-}>;
-export {};

package/dist/tools/bio/search-gwas-catalog.js

@@ -1,172 +0,0 @@
-/**
- * searchGwasCatalog — search NHGRI-EBI GWAS Catalog for SNP-trait associations.
- *
- * Public REST API, no key required. Three search modes:
- *   - 'gene' — gene-trait associations (via SNP-by-gene lookup, then assocs)
- *   - 'trait' — trait-gene associations (via EFO trait search, then assocs)
- *   - 'variant' — direct rsID lookup
- */
-import { ok } from "neverthrow";
-import { z } from "zod";
-import { defineTool } from "../define-tool.js";
-import { apiFetchValidated, describeApiError } from "../lib/api-utils.js";
-import { GWAS_BASE, GWAS_HEADERS } from "../lib/gwas-catalog-config.js";
-// GWAS Catalog raw wire shapes (HAL+JSON), validated at the fetch boundary.
-// Every field is optional because the API omits absent values; leaf strings
-// that the API can return as an explicit `null` are `.nullable()`.
-const RawGwasStudySchema = z.object({
-    accessionId: z.string().optional(),
-    pubmedId: z.string().optional(),
-    initialSampleSize: z.string().optional(),
-});
-// `_snpRsId` is not on the wire — the 'gene' search path assigns it after
-// parsing (`a._snpRsId = snp.rsId`), so it stays a writable optional field.
-const RawGwasAssociationSchema = z.object({
-    _snpRsId: z.string().optional(),
-    loci: z
-        .array(z.object({
-        strongestRiskAlleles: z.array(z.object({ riskAlleleName: z.string().nullable().optional() })).optional(),
-        authorReportedGenes: z.array(z.object({ geneName: z.string().nullable().optional() })).optional(),
-    }))
-        .optional(),
-    efoTraits: z.array(z.object({ trait: z.string().nullable().optional() })).optional(),
-    study: RawGwasStudySchema.optional(),
-    pvalueMantissa: z.number().optional(),
-    pvalueExponent: z.number().optional(),
-    riskFrequency: z.string().optional(),
-    orPerCopyNum: z.number().nullable().optional(),
-    betaNum: z.number().nullable().optional(),
-    range: z.string().optional(),
-});
-const GwasEmbeddedSchema = z.object({
-    _embedded: z.object({ associations: z.array(RawGwasAssociationSchema).optional() }).optional(),
-    page: z.object({ totalElements: z.number().optional() }).optional(),
-});
-const GwasTraitSearchResponseSchema = z.object({
-    _embedded: z
-        .object({
-        efoTraits: z.array(z.object({ _links: z.object({ self: z.object({ href: z.string().optional() }).optional() }).optional() })).optional(),
-    })
-        .optional(),
-});
-const GwasSnpSearchResponseSchema = z.object({
-    _embedded: z
-        .object({
-        singleNucleotidePolymorphisms: z
-            .array(z.object({
-            rsId: z.string().optional(),
-            _links: z.object({ associations: z.object({ href: z.string().optional() }).optional() }).optional(),
-        }))
-            .optional(),
-    })
-        .optional(),
-});
-function mapAssociation(a) {
-    const loci = a.loci ?? [];
-    const riskAlleles = loci.flatMap((l) => l.strongestRiskAlleles?.map((ra) => String(ra.riskAlleleName ?? "")) ?? []);
-    const genes = loci.flatMap((l) => l.authorReportedGenes?.map((g) => String(g.geneName ?? "")) ?? []);
-    const traits = (a.efoTraits ?? []).map((t) => String(t.trait ?? ""));
-    const study = a.study ?? {};
-    const pMantissa = a.pvalueMantissa ?? 0;
-    const pExponent = a.pvalueExponent ?? 0;
-    return {
-        rsId: String(a._snpRsId ?? riskAlleles[0]?.split("-")[0] ?? ""),
-        pValue: pMantissa * Math.pow(10, pExponent),
-        pValueMantissa: pMantissa,
-        pValueExponent: pExponent,
-        riskAllele: riskAlleles.join(", "),
-        riskFrequency: String(a.riskFrequency ?? ""),
-        orBeta: (a.orPerCopyNum ?? a.betaNum ?? null),
-        ci: String(a.range ?? ""),
-        trait: traits.join("; "),
-        mappedGenes: [...new Set(genes)],
-        studyAccession: String(study.accessionId ?? ""),
-        pubmedId: String(study.pubmedId ?? ""),
-        sampleSize: String(study.initialSampleSize ?? ""),
-    };
-}
-export const searchGwasCatalogTool = defineTool({
-    id: "search_gwas_catalog",
-    description: "Search the NHGRI-EBI GWAS Catalog for genome-wide association study results. " +
-        "Returns SNP associations with traits/diseases, effect sizes, p-values, and mapped genes. " +
-        "Use to find genetic evidence linking genes to phenotypes for target validation or " +
-        "Mendelian randomization support.",
-    inputSchema: z.object({
-        query: z.string().describe("Gene symbol (e.g. PCSK9), trait keyword (e.g. cholesterol), or rsID (e.g. rs11591147)"),
-        searchType: z
-            .enum(["gene", "trait", "variant"])
-            .describe("'gene' for gene-trait associations, 'trait' for trait-gene associations, 'variant' for a specific rsID"),
-        pValueThreshold: z.number().default(5e-8).describe("P-value threshold for genome-wide significance"),
-        limit: z.number().int().min(1).max(100).default(25).describe("Max results to return"),
-    }),
-    execute: async ({ query, searchType, pValueThreshold = 5e-8, limit = 25 }) => {
-        let url;
-        if (searchType === "variant") {
-            const rsId = query.startsWith("rs") ? query : `rs${query}`;
-            url = `${GWAS_BASE}/singleNucleotidePolymorphisms/${rsId}/associations?projection=associationBySnp`;
-        }
-        else if (searchType === "gene") {
-            url = `${GWAS_BASE}/singleNucleotidePolymorphisms/search/findByGene?geneName=${encodeURIComponent(query)}&projection=snpByGene`;
-        }
-        else {
-            url = `${GWAS_BASE}/efoTraits/search/findBySearchQuery?query=${encodeURIComponent(query)}`;
-        }
-        if (searchType === "trait") {
-            const traitRes = await apiFetchValidated(url, GwasTraitSearchResponseSchema, { headers: GWAS_HEADERS });
-            if (traitRes.isErr())
-                throw new Error(describeApiError(traitRes.error));
-            const traits = traitRes.value?._embedded?.efoTraits ?? [];
-            if (traits.length === 0) {
-                return ok({ totalFound: 0, associations: [] });
-            }
-            const traitUri = traits[0]?._links?.self?.href;
-            if (!traitUri) {
-                return ok({ totalFound: 0, associations: [] });
-            }
-            const traitId = traitUri.split("/").pop();
-            url = `${GWAS_BASE}/efoTraits/${traitId}/associations?size=${limit}`;
-        }
-        if (searchType === "gene") {
-            const snpRes = await apiFetchValidated(url, GwasSnpSearchResponseSchema, { headers: GWAS_HEADERS });
-            if (snpRes.isErr())
-                throw new Error(describeApiError(snpRes.error));
-            const snps = snpRes.value?._embedded?.singleNucleotidePolymorphisms ?? [];
-            const allAssocs = [];
-            for (const snp of snps.slice(0, Math.min(limit, 10))) {
-                const assocLink = snp?._links?.associations?.href;
-                if (!assocLink)
-                    continue;
-                const aRes = await apiFetchValidated(assocLink, GwasEmbeddedSchema, {
-                    headers: GWAS_HEADERS,
-                });
-                if (aRes.isOk()) {
-                    for (const a of aRes.value?._embedded?.associations ?? []) {
-                        a._snpRsId = snp.rsId;
-                        allAssocs.push(a);
-                    }
-                }
-                if (allAssocs.length >= limit)
-                    break;
-            }
-            return ok({
-                totalFound: allAssocs.length,
-                associations: allAssocs.slice(0, limit).map(mapAssociation),
-            });
-        }
-        const res = await apiFetchValidated(url, GwasEmbeddedSchema, { headers: GWAS_HEADERS });
-        if (res.isErr())
-            throw new Error(describeApiError(res.error));
-        const rawAssocs = res.value?._embedded?.associations ?? [];
-        const totalFound = res.value?.page?.totalElements ?? rawAssocs.length;
-        const filtered = rawAssocs
-            .filter((a) => {
-            const p = (a.pvalueMantissa ?? 1) * Math.pow(10, a.pvalueExponent ?? 0);
-            return p <= pValueThreshold;
-        })
-            .slice(0, limit);
-        return ok({
-            totalFound,
-            associations: filtered.map(mapAssociation),
-        });
-    },
-});

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

@@ -1,12 +0,0 @@
-/**
- * searchPathway — search biological pathways via KEGG and Reactome.
- */
-export declare const searchPathwayTool: import("../define-tool.js").Tool<{
-    query: string;
-    source: "kegg" | "reactome" | "both";
-    organism: string;
-    includeGenes: boolean;
-    maxResults: number;
-}, {
-    pathways: import("../lib/pathway-client.js").Pathway[];
-}>;

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

@@ -1,32 +0,0 @@
-/**
- * searchPathway — search biological pathways via KEGG and Reactome.
- */
-import { ok } from "neverthrow";
-import { z } from "zod";
-import { defineTool } from "../define-tool.js";
-import { searchPathways } from "../lib/pathway-client.js";
-export const searchPathwayTool = defineTool({
-    id: "search_pathway",
-    description: "Search biological pathways in KEGG and/or Reactome databases. " +
-        "Returns pathway IDs, names, URLs, and optionally gene lists. " +
-        "Use source='both' to query both databases in parallel.",
-    inputSchema: z.object({
-        query: z.string().min(1).describe("Pathway search term (e.g. 'apoptosis', 'MAPK signaling')"),
-        source: z.enum(["kegg", "reactome", "both"]).default("both").describe("Which database to search"),
-        organism: z
-            .string()
-            .default("hsa")
-            .describe("KEGG organism code (e.g. 'hsa' for human, 'mmu' for mouse). " + "Automatically mapped to species name for Reactome."),
-        includeGenes: z.boolean().default(false).describe("Whether to fetch gene lists for each pathway (slower)"),
-        maxResults: z.number().int().min(1).max(50).default(10),
-    }),
-    execute: async ({ query, source, organism, includeGenes, maxResults }) => {
-        const pathways = await searchPathways(query, {
-            source,
-            organism,
-            includeGenes,
-            maxResults,
-        });
-        return ok({ pathways });
-    },
-});

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

@@ -1,17 +0,0 @@
-/**
- * searchPharmgkb — search PharmGKB for pharmacogenomic clinical annotations.
- */
-export declare const searchPharmgkbTool: import("../define-tool.js").Tool<{
-    query: string;
-    searchType: "drug" | "gene";
-    limit: number;
-}, {
-    annotations: {
-        gene: string;
-        drug: string;
-        phenotype: null;
-        levelOfEvidence: string;
-        guidelineSource: null;
-        summary: null;
-    }[];
-}>;

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

@@ -1,52 +0,0 @@
-/**
- * searchPharmgkb — search PharmGKB for pharmacogenomic clinical annotations.
- */
-import { ok } from "neverthrow";
-import { z } from "zod";
-import { defineTool } from "../define-tool.js";
-import { apiFetchValidated, describeApiError } from "../lib/api-utils.js";
-import { PHARMGKB_BASE, PHARMGKB_HEADERS } from "../lib/pharmgkb-config.js";
-// Raw PharmGKB clinicalAnnotation wire shape, validated at the fetch boundary.
-// Every field is optional because the API omits absent values; the mapper in
-// `execute` folds request context (`query`) into its output, so the schema
-// models only the raw wire and the mapping stays where it is.
-const PharmgkbAnnotationSchema = z.object({
-    location: z.object({ genes: z.array(z.object({ symbol: z.string().optional() })).optional() }).optional(),
-    relatedChemicals: z.array(z.object({ name: z.string().optional() })).optional(),
-    levelOfEvidence: z.object({ term: z.string().optional() }).optional(),
-});
-const PharmgkbResponseSchema = z.object({
-    data: z.array(PharmgkbAnnotationSchema).optional(),
-});
-export const searchPharmgkbTool = defineTool({
-    id: "search_pharmgkb",
-    description: "Search PharmGKB clinical annotations for a gene-drug pharmacogenomic link — use it to judge whether a gene affects a drug's metabolism, efficacy, or toxicity. " +
-        "Returns annotations[]: { gene, drug, levelOfEvidence (PharmGKB 1A…4, where 1A is guideline-backed) }. The phenotype, guidelineSource and summary fields are always null " +
-        "in this tool's output — treat levelOfEvidence as the only strength signal and do not attribute CPIC/DPWG guideline text to it. " +
-        "Matching is an exact field filter, not a search: 'CYP2D6' resolves, 'cytochrome P450 2D6' does not. " +
-        "An empty annotations array is valid no-data (no curated PGx link) — do not retry.",
-    inputSchema: z.object({
-        query: z
-            .string()
-            .describe("Exact gene symbol (e.g. 'CYP2D6') when searchType='gene', or exact drug name (e.g. 'tamoxifen') when searchType='drug'. No fuzzy matching."),
-        searchType: z.enum(["gene", "drug"]).describe("'gene' filters PharmGKB on location.genes.symbol; 'drug' filters on relatedChemicals.name."),
-        limit: z.number().int().min(1).max(50).default(20).describe("Max annotations to return (default 20, max 50); applied client-side after the fetch."),
-    }),
-    execute: async ({ query, searchType, limit = 20 }) => {
-        const filter = searchType === "gene" ? `location.genes.symbol=${encodeURIComponent(query)}` : `relatedChemicals.name=${encodeURIComponent(query)}`;
-        const endpoint = `${PHARMGKB_BASE}/clinicalAnnotation?${filter}`;
-        const res = await apiFetchValidated(endpoint, PharmgkbResponseSchema, { headers: PHARMGKB_HEADERS });
-        if (res.isErr())
-            throw new Error(describeApiError(res.error));
-        const data = res.value?.data ?? [];
-        const annotations = data.slice(0, limit).map((ann) => ({
-            gene: ann.location?.genes?.map((g) => g.symbol).join(", ") ?? query,
-            drug: ann.relatedChemicals?.map((c) => c.name).join(", ") ?? "",
-            phenotype: null,
-            levelOfEvidence: ann.levelOfEvidence?.term ?? "Unknown",
-            guidelineSource: null,
-            summary: null,
-        }));
-        return ok({ annotations });
-    },
-});

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

@@ -1,64 +0,0 @@
-/**
- * executePlan — launch the DBOS `executeAnalysis` parent workflow for an
- * approved plan.
- *
- * Results are pull-only: the tool does NOT register a `.then(saveRunResult)`
- * or any completion callback that writes to the conversation thread. The
- * conversation agent retrieves run results via `inspectRun` on a later turn.
- *
- * Authorization contract: the tool runs in the chat HTTP route, so its session
- * carries the live auth. It authorizes through the injected `RunAuthorizer`
- * seam and never reads a credential. The flow is dedup → reserve → authorize
- * → startWorkflow:
- *
- *   1. Dedup pre-check via `queryActiveRun`. On hit, return the existing
- *      `runId` with no authorization and no `startWorkflow`.
- *   2. Reserve the slot: `insertRun` the `cortex_runs` row (`runId =
- *      randomUUID()`, the bare UUID that IS the DBOS workflowID) BEFORE
- *      authorizing. The partial-unique index is the race backstop; the loser
- *      returns the winner's `runId` without authorizing — nothing to revoke.
- *   3. `runAuthorizer.authorize({ ..., frame: { runId } })` — authorizes the
- *      run; the authorizer's persisted handle now lands because the row
- *      exists. On failure, mark the reserved row `failed` (releasing the dedup
- *      slot for a retry) and rethrow.
- *   4. `runLauncher.launch(executeAnalysis, { workflowId: runId }, ...)`,
- *      passing the `RunSession` in the workflow input. On failure, revoke + mark
- *      failed.
- */
-import type { Pool } from "pg";
-import type { ResourcePolicy } from "../config/resource-limits.js";
-import type { RunAuthorizer } from "../execution/run-authorizer.js";
-import type { RunLauncher } from "../execution/run-launcher.js";
-import type { ExecuteAnalysisInput, ExecuteAnalysisResult } from "../workflows/execute-analysis.js";
-type ExecuteAnalysisWorkflow = (input: ExecuteAnalysisInput) => Promise<ExecuteAnalysisResult>;
-export interface ExecutePlanToolDeps {
-    readonly pool: Pool;
-    /** Registered `executeAnalysis` workflow callable — produced by `registerExecuteAnalysis` (wired by `assembleCoreRuntime`). */
-    readonly executeAnalysisWorkflow: ExecuteAnalysisWorkflow;
-    /** Authorizes the run at the async edge and revokes on the abort paths. */
-    readonly runAuthorizer: RunAuthorizer;
-    /** Starts the durable run — the durability engine stays behind this seam. */
-    readonly runLauncher: RunLauncher;
-    /**
-     * Host resource policy. The machine budget is snapshotted into the workflow
-     * input here at the async edge — the workflow body never reads live config,
-     * so a mid-run config edit cannot change a running run's admission decisions.
-     */
-    readonly resourcePolicy?: ResourcePolicy;
-}
-export declare class PlanNotFoundError extends Error {
-    constructor(planId: string);
-}
-export declare class PlanMalformedError extends Error {
-    constructor(planId: string);
-}
-export declare class PlanValidationError extends Error {
-    readonly errors: string[];
-    constructor(planId: string, errors: string[]);
-}
-export declare function createExecutePlanTool(deps: ExecutePlanToolDeps): import("./define-tool.js").Tool<{
-    planId: string;
-}, {
-    runId: string;
-}>;
-export {};