@inflexa-ai/harness 0.13.0 → 0.14.1

package/dist/workflows/execute-analysis.js

@@ -97,6 +97,52 @@ function emitProvenanceGuarded(deps, event) {
         logger.error("emitProvenance threw", { runId: event.runId, event: event.type, ...logger.errorFields(err) });
     }
 }
+/**
+ * Build the whole-run snapshot from the workflow input and the scheduler's live step state.
+ *
+ * Pure, so every emission point produces an identically-shaped payload from one place — a second
+ * construction path is exactly how "a transition happened" acquires two definitions that drift.
+ * The human `name` joins through `input.planStepById` because `input.steps` is the scheduler's
+ * narrow `{id, depends_on}` projection and carries no plan vocabulary.
+ */
+function buildRunObservation(args) {
+    const { input, runId, status, stepStates } = args;
+    return {
+        runId,
+        analysisId: input.analysisId,
+        status,
+        steps: input.steps.map((s) => {
+            const rt = stepStates.get(s.id);
+            return {
+                id: s.id,
+                name: input.planStepById[s.id]?.name ?? s.id,
+                agent: input.agentByStepId[s.id] ?? "unknown",
+                // A step absent from the map has not been reached yet; `pending` is its honest state.
+                status: rt?.status ?? "pending",
+                ...(rt?.durationMs !== undefined ? { durationMs: rt.durationMs } : {}),
+                ...(rt?.error !== undefined ? { error: rt.error } : {}),
+            };
+        }),
+    };
+}
+/**
+ * Fire the optional run observer, isolating a throwing host callback from the workflow.
+ *
+ * Deliberately a sibling of {@link emitProvenanceGuarded} rather than a shared helper: the two
+ * seams carry unrelated payloads and must stay independently removable, and one shared guard would
+ * have to pick a single logger namespace, making it lie about whichever seam it is not named for.
+ */
+function observeRunGuarded(deps, observation) {
+    if (!deps.observeRun)
+        return;
+    const logger = (deps.logger ?? createNoopLogger()).named("executeAnalysis.observe");
+    try {
+        deps.observeRun(observation);
+    }
+    catch (err) {
+        logger.error("observeRun threw", { runId: observation.runId, status: observation.status, ...logger.errorFields(err) });
+    }
+}
 /**
  * Project the sandbox-step input handed to each child. The parent owns the
  * level computation and the seed (`prompt`, composed by `composeStepSeed` at
@@ -379,6 +425,10 @@ export async function runExecuteAnalysisBody(input, deps) {
         stepCount: input.steps.length,
         atMs: startedAtMs,
     });
+    // Opening snapshot: every step pending. The scheduler's own map does not exist yet, and an
+    // empty one yields exactly that — so a host has the run's full shape before the first dispatch
+    // rather than learning the step list from whichever transition happens to land first.
+    observeRunGuarded(deps, buildRunObservation({ input, runId, status: "running", stepStates: new Map() }));
     // (2-4) Scheduler loop + failure isolation + pause cascade.
     const final = await runSchedulerLoop({
         input,
@@ -490,6 +540,11 @@ export async function runExecuteAnalysisBody(input, deps) {
         synthesisOutcome,
         deps,
     });
+    // Terminal snapshot, fired here rather than inside `collectAndComplete` because this is the
+    // first point where BOTH the derived final status and the scheduler's final step map are in
+    // hand. It precedes the budget self-cancel below on purpose: that branch raises out of the
+    // body, so an observer placed after it would never see a budget-paused run's last state.
+    observeRunGuarded(deps, buildRunObservation({ input, runId, status: result.status, stepStates: final.stepStates }));
     // Synthesis failure takes priority over the budget-exceeded cascade: a run
     // whose synthesis threw is definitively failed (ERROR), not a resumable
     // budget pause. Only self-cancel when synthesis succeeded.
@@ -602,7 +657,14 @@ async function runSchedulerLoop(args) {
                 const rt = stepRuntime.get(s.id);
                 const entry = {
                     id: s.id,
-                    name: s.id,
+                    // `input.steps` is the SCHEDULER's projection — `{id, depends_on}` and nothing
+                    // else — so the human name has to be joined from the snapshotted plan step. A
+                    // consumer reading `name` is reading it to say what the step is FOR, which the
+                    // id (a `T{track}S{step}` slug) cannot answer. Falling back to the id keeps the
+                    // field populated for a step missing from the snapshot rather than emitting an
+                    // empty label; `planStepById` is complete by contract (dispatch throws on a
+                    // miss), so the fallback is unreachable in practice.
+                    name: input.planStepById[s.id]?.name ?? s.id,
                     agent: input.agentByStepId[s.id] ?? "unknown",
                     status: rt.status,
                     level: levels.get(s.id) ?? 0,
@@ -612,9 +674,18 @@ async function runSchedulerLoop(args) {
                     entry.durationMs = rt.durationMs;
                 if (rt.error !== undefined)
                     entry.error = rt.error;
+                // `artifactCount` and `summary` are declared on `DagStepState` and deliberately not
+                // set: the parent holds neither at snapshot time, and a placeholder would make a
+                // consumer's rendering confidently wrong rather than honestly incomplete.
                 return entry;
             }),
         });
+        // The host observer rides the DAG emission rather than getting its own instrumentation
+        // points: these call sites already ARE the complete set of run-state transitions, and a
+        // second set would drift from this one. Status is `running` here by construction — the
+        // scheduler loop only emits while it is still scheduling; the terminal snapshot is fired by
+        // the body once `collectAndComplete` has derived the final status.
+        observeRunGuarded(deps, buildRunObservation({ input, runId, status: "running", stepStates: stepRuntime }));
     };
     const dbosParentId = DBOS.workflowID ?? workflowId;
     const dispatchReady = async () => {
@@ -841,7 +912,7 @@ async function runSchedulerLoop(args) {
         });
     }
     await drainBudgetExceededNotifications(budgetExceededChildIds);
-    return { completed, failed, canceled, budgetExceeded, failureReason };
+    return { completed, failed, canceled, budgetExceeded, failureReason, stepStates: stepRuntime };
 }
 async function drainBudgetExceededNotifications(childIds) {
     while (true) {

package/dist/workflows/sandbox-step.js

@@ -33,7 +33,7 @@ import { unwrapOrThrow } from "../lib/result.js";
 import { isBudgetExceeded } from "../loop/budget-exceeded.js";
 import { runAgent } from "../loop/run-agent.js";
 import { durableStep } from "../loop/run-step.js";
-import { activityForTool, applyTreeDelta, isChatDataPart, sandboxTreeDelta } from "../sandbox/sandbox-step-translate.js";
+import { activityForTool, applyTreeDelta, isChatDataPart, sandboxTreeDelta, stepPartId } from "../sandbox/sandbox-step-translate.js";
 import { forSubAgent } from "../auth/types.js";
 import { walkStepArtifacts } from "../execution/post-step.js";
 import { collectStepOutputs, generateStepFileMetadata, generateStepSummaryAndWrite, reconcileAndRegisterStepArtifacts, vectorIndexStepOutputs, } from "../execution/post-step-pipeline.js";
@@ -61,16 +61,6 @@ function nextFunctionIdFactory() {
     let n = 0;
     return () => `fn-${(n++).toString(36)}`;
 }
-/**
- * Stable reconciliation id for a step's reconciling parts
- * (`data-step-activity`, `data-step-file-tree`). One id per (runId, stepId)
- * so the run-stream fold collapses every phase transition latest-wins onto
- * a single frame. The client keys these by `stepId`, but the server fold
- * keys by part `id`, so the id MUST be unique per step within the run.
- */
-function stepPartId(kind, runId, stepId) {
-    return `${kind}-${runId}-${stepId}`;
-}
 /**
  * Map an internal step failure to a user-safe string. Internal detail (file
  * paths, content hashes, managed-root rejection reasons, stack traces) stays in the pod

package/dist/workflows/target-assessment/decisions/index.d.ts

@@ -43,9 +43,9 @@ export declare const DrugsInClassOutputSchema: z.ZodObject<{
         firstApproval: z.ZodNullable<z.ZodNumber>;
         moleculeType: z.ZodNullable<z.ZodString>;
         sources: z.ZodArray<z.ZodEnum<{
-            chembl: "chembl";
             dgidb: "dgidb";
             drugbank: "drugbank";
+            chembl: "chembl";
         }>>;
     }, z.core.$strip>>;
     total: z.ZodNumber;

package/dist/workflows/target-assessment/phase4-assemble.d.ts

@@ -1707,8 +1707,8 @@ export declare const Phase4OutputSchema: z.ZodObject<{
                                 medium: "medium";
                                 low: "low";
                                 absent: "absent";
-                                not_loaded: "not_loaded";
                                 no_data: "no_data";
+                                not_loaded: "not_loaded";
                             }>;
                         }, z.core.$strip>>;
                         per_species_coverage: z.ZodRecord<z.ZodString, z.ZodEnum<{

package/dist/workflows/target-assessment/steps/phase2-aggregate.d.ts

@@ -53,9 +53,9 @@ export declare const Phase2AggregateInputSchema: z.ZodObject<{
                 firstApproval: z.ZodNullable<z.ZodNumber>;
                 moleculeType: z.ZodNullable<z.ZodString>;
                 sources: z.ZodArray<z.ZodEnum<{
-                    chembl: "chembl";
                     dgidb: "dgidb";
                     drugbank: "drugbank";
+                    chembl: "chembl";
                 }>>;
             }, z.core.$strip>>;
             total: z.ZodNumber;
@@ -672,9 +672,9 @@ export declare const Phase2BundleSchema: z.ZodObject<{
                     firstApproval: z.ZodNullable<z.ZodNumber>;
                     moleculeType: z.ZodNullable<z.ZodString>;
                     sources: z.ZodArray<z.ZodEnum<{
-                        chembl: "chembl";
                         dgidb: "dgidb";
                         drugbank: "drugbank";
+                        chembl: "chembl";
                     }>>;
                 }, z.core.$strip>>;
                 total: z.ZodNumber;

package/dist/workflows/target-assessment/steps/phase3-aggregate.d.ts

@@ -757,9 +757,9 @@ export declare const Phase3BundleSchema: z.ZodObject<{
                         firstApproval: z.ZodNullable<z.ZodNumber>;
                         moleculeType: z.ZodNullable<z.ZodString>;
                         sources: z.ZodArray<z.ZodEnum<{
-                            chembl: "chembl";
                             dgidb: "dgidb";
                             drugbank: "drugbank";
+                            chembl: "chembl";
                         }>>;
                     }, z.core.$strip>>;
                     total: z.ZodNumber;

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "@inflexa-ai/harness",
-    "version": "0.13.0",
+    "version": "0.14.1",
     "description": "Host-agnostic bioinformatics agent harness \u2014 hand-rolled agent loop, DBOS-durable workflows, sandboxed compute.",
     "license": "Apache-2.0",
     "type": "module",

package/dist/tools/bio/check-safety-panel.d.ts

@@ -1,35 +0,0 @@
-/**
- * checkSafetyPanel — look up identifiers against the curated
- * secondary-pharmacology safety target panel.
- */
-export declare const checkSafetyPanelTool: import("../define-tool.js").Tool<{
-    identifiers: string[];
-    identifier_type: "auto" | "gene_symbol" | "uniprot" | "chembl_id";
-    filter_organ?: "hematologic" | "metabolic" | "immune" | "hepatic" | "cns" | "renal" | "respiratory" | "cardiac" | "gi" | undefined;
-}, {
-    matches: {
-        input: string;
-        matched_entry: {
-            chembl_id: string;
-            gene_symbol: string;
-            uniprot: string;
-            name: string;
-            organ_system: "hematologic" | "metabolic" | "immune" | "hepatic" | "cns" | "renal" | "respiratory" | "cardiac" | "gi";
-            clinical_consequence: string;
-            severity: "high" | "medium" | "low";
-            references: string[];
-            ensembl_gene_id?: string | undefined;
-        } | null;
-    }[];
-    summary: {
-        total_input: number;
-        matched: number;
-        by_severity: {
-            high: number;
-            medium: number;
-            low: number;
-        };
-        by_organ: Record<string, number>;
-    };
-    panel_version: string;
-}>;

package/dist/tools/bio/check-safety-panel.js

@@ -1,76 +0,0 @@
-/**
- * checkSafetyPanel — look up identifiers against the curated
- * secondary-pharmacology safety target panel.
- */
-import { ok } from "neverthrow";
-import { z } from "zod";
-import { CHEMBL_RE, ORGAN_SYSTEMS, SafetyPanelFileSchema, UNIPROT_RE } from "../../data/safety-panel-schema.js";
-import panelData from "../../data/safety-panel.json" with { type: "json" };
-import { defineTool } from "../define-tool.js";
-const PANEL = SafetyPanelFileSchema.parse(panelData);
-const BY_CHEMBL = new Map(PANEL.targets.map((t) => [t.chembl_id, t]));
-const BY_GENE = new Map(PANEL.targets.map((t) => [t.gene_symbol, t]));
-const BY_UNIPROT = new Map(PANEL.targets.map((t) => [t.uniprot, t]));
-function detectType(id) {
-    if (CHEMBL_RE.test(id))
-        return "chembl_id";
-    if (UNIPROT_RE.test(id))
-        return "uniprot";
-    return "gene_symbol";
-}
-function lookup(id, type) {
-    switch (type) {
-        case "chembl_id":
-            return BY_CHEMBL.get(id) ?? null;
-        case "gene_symbol":
-            return BY_GENE.get(id.toUpperCase()) ?? null;
-        case "uniprot":
-            return BY_UNIPROT.get(id) ?? null;
-    }
-}
-export const checkSafetyPanelTool = defineTool({
-    id: "check_safety_panel",
-    description: "Look up identifiers (ChEMBL ID, gene symbol, or UniProt accession) against the curated " +
-        "secondary-pharmacology safety target panel. Returns organ system, severity, and clinical " +
-        "consequence for each matched target. Use as a fast first-pass off-target liability check; " +
-        "for comprehensive assessment also call get-target-safety and search-toxcast.",
-    inputSchema: z.object({
-        identifiers: z.array(z.string().min(1)).min(0).max(200).describe("0-200 identifiers (ChEMBL IDs, gene symbols, or UniProt accessions)."),
-        identifier_type: z
-            .enum(["chembl_id", "gene_symbol", "uniprot", "auto"])
-            .default("auto")
-            .describe("Identifier interpretation. 'auto' detects per-input."),
-        filter_organ: z.enum(ORGAN_SYSTEMS).optional().describe("Restrict matches to this organ system."),
-    }),
-    execute: async ({ identifiers, identifier_type = "auto", filter_organ }) => {
-        const matches = identifiers.map((input) => {
-            const type = identifier_type === "auto" ? detectType(input) : identifier_type;
-            let entry = lookup(input, type);
-            if (entry && filter_organ && entry.organ_system !== filter_organ) {
-                entry = null;
-            }
-            return { input, matched_entry: entry };
-        });
-        const bySeverity = { high: 0, medium: 0, low: 0 };
-        const byOrgan = {};
-        let matched = 0;
-        for (const m of matches) {
-            if (!m.matched_entry)
-                continue;
-            matched++;
-            bySeverity[m.matched_entry.severity]++;
-            const o = m.matched_entry.organ_system;
-            byOrgan[o] = (byOrgan[o] ?? 0) + 1;
-        }
-        return ok({
-            matches,
-            summary: {
-                total_input: identifiers.length,
-                matched,
-                by_severity: bySeverity,
-                by_organ: byOrgan,
-            },
-            panel_version: PANEL.panel_version,
-        });
-    },
-});

package/dist/tools/bio/get-impc-ko-profile.d.ts

@@ -1,9 +0,0 @@
-/**
- * getImpcKoProfile tool — mouse knockout phenotype profile via IMPC Solr.
- */
-import { buildViabilityCalls, derivedViability, parsePhenotypeResponse } from "../lib/impc-client.js";
-export type { PhenotypeProfile, ViabilityCall, ViabilityCategory } from "../lib/impc-client.js";
-export { buildViabilityCalls, derivedViability, parsePhenotypeResponse };
-export declare const getImpcKoProfileTool: import("../define-tool.js").Tool<{
-    geneSymbol: string;
-}, import("../lib/impc-client.js").KoPhenotypeProfile>;

package/dist/tools/bio/get-impc-ko-profile.js

@@ -1,23 +0,0 @@
-/**
- * getImpcKoProfile tool — mouse knockout phenotype profile via IMPC Solr.
- */
-import { ok } from "neverthrow";
-import { z } from "zod";
-import { defineTool } from "../define-tool.js";
-import { buildViabilityCalls, derivedViability, getKoPhenotypeProfile, parsePhenotypeResponse } from "../lib/impc-client.js";
-export { buildViabilityCalls, derivedViability, parsePhenotypeResponse };
-export const getImpcKoProfileTool = defineTool({
-    id: "get_impc_ko_profile",
-    description: "Get the mouse-knockout phenotype profile for a gene from IMPC — the in-vivo loss-of-function evidence for target tractability and essentiality " +
-        "('what happens to PAX5 knockout mice?', 'is loss of CASP8 lethal?'). " +
-        "Takes a human gene symbol and maps it to the mouse ortholog itself. Returns a top-line pre-weaning viability call (lethal_pre_weaning | subviable | viable | null) with its " +
-        "per-zygosity breakdown, the significant MP phenotype terms ordered by best p-value, the affected organ systems ranked by phenotype count, and a sex-dimorphism flag. " +
-        "An all-empty profile (null mouseMarkerSymbol, null viability, no phenotype terms) means the gene has not been IMPC-phenotyped — common and valid. Do NOT retry on empty output.",
-    inputSchema: z.object({
-        geneSymbol: z
-            .string()
-            .min(1)
-            .describe("HUMAN gene symbol, e.g. 'BRCA1' — one gene per call. The mouse ortholog is resolved internally; do not pass a mouse symbol or an MGI ID."),
-    }),
-    execute: async ({ geneSymbol }) => ok(await getKoPhenotypeProfile(geneSymbol)),
-});

package/dist/tools/bio/lookup-go-term.d.ts

@@ -1,31 +0,0 @@
-/**
- * lookupGoTerm — look up Gene Ontology terms via the QuickGO API (EBI).
- *
- * Supports direct ID lookup, keyword search, and gene annotation retrieval.
- * Multiple modes can be combined in a single call.
- */
-interface GoTerm {
-    id: string;
-    name: string;
-    definition?: string;
-    aspect?: string;
-}
-interface GoAnnotation {
-    geneProductId: string;
-    goId: string;
-    goName: string;
-    aspect?: string;
-    evidenceCode?: string;
-    qualifier?: string;
-}
-export declare const lookupGoTermTool: import("../define-tool.js").Tool<{
-    limit: number;
-    goId?: string | undefined;
-    query?: string | undefined;
-    geneProductId?: string | undefined;
-    taxonId?: number | undefined;
-}, {
-    terms: GoTerm[] | undefined;
-    annotations: GoAnnotation[] | undefined;
-}>;
-export {};

package/dist/tools/bio/lookup-go-term.js

@@ -1,116 +0,0 @@
-/**
- * lookupGoTerm — look up Gene Ontology terms via the QuickGO API (EBI).
- *
- * Supports direct ID lookup, keyword search, and gene annotation retrieval.
- * Multiple modes can be combined in a single call.
- */
-import { ok } from "neverthrow";
-import { z } from "zod";
-import { defineTool } from "../define-tool.js";
-import { apiFetchValidated, describeApiError } from "../lib/api-utils.js";
-const QUICKGO_BASE = "https://www.ebi.ac.uk/QuickGO/services";
-const HEADERS = { Accept: "application/json" };
-// 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
-    .object({
-    results: z
-        .array(z.object({
-        id: z.string().optional(),
-        name: z.string().optional(),
-        definition: z.object({ text: z.string().optional() }).nullable().optional(),
-        aspect: z.string().optional(),
-    }))
-        .optional(),
-})
-    .transform((res) => (res.results ?? []).map((t) => ({
-    id: t.id ?? "",
-    name: t.name ?? "",
-    definition: t.definition?.text ?? undefined,
-    aspect: t.aspect ?? undefined,
-})));
-const GoAnnotationResponseSchema = z
-    .object({
-    results: z
-        .array(z.object({
-        geneProductId: z.string().optional(),
-        goId: z.string().optional(),
-        goName: z.string().optional(),
-        goAspect: z.string().optional(),
-        goEvidence: z.string().optional(),
-        qualifier: z.string().optional(),
-    }))
-        .optional(),
-})
-    .transform((res) => (res.results ?? []).map((a) => ({
-    geneProductId: a.geneProductId ?? "",
-    goId: a.goId ?? "",
-    goName: a.goName ?? "",
-    aspect: a.goAspect ?? undefined,
-    evidenceCode: a.goEvidence ?? undefined,
-    qualifier: a.qualifier ?? undefined,
-})));
-export const lookupGoTermTool = defineTool({
-    id: "lookup_go_term",
-    description: "Look up Gene Ontology terms from QuickGO (EBI). " +
-        "Can look up a term by GO ID, search by keyword, or retrieve GO annotations " +
-        "for a specific gene/protein. At least one of goId, query, or geneProductId must be provided.",
-    inputSchema: z
-        .object({
-        goId: z
-            .string()
-            .regex(/^GO:\d{7}$/)
-            .optional()
-            .describe("Specific GO term ID (e.g. 'GO:0008150')"),
-        query: z.string().optional().describe("Free-text search for GO terms (e.g. 'apoptotic process')"),
-        limit: z.number().int().min(1).max(100).default(10).describe("Maximum number of results per query type"),
-        geneProductId: z.string().optional().describe("UniProt ID to get annotations for (e.g. 'P04637')"),
-        taxonId: z.number().int().optional().describe("NCBI Taxon ID to filter annotations (9606 = human, 10090 = mouse)"),
-    })
-        .refine((d) => d.goId || d.query || d.geneProductId, {
-        message: "At least one of goId, query, or geneProductId is required",
-    }),
-    execute: async ({ goId, query, limit, geneProductId, taxonId }) => {
-        const tasks = [];
-        let terms;
-        let annotations;
-        if (goId) {
-            tasks.push((async () => {
-                const res = await apiFetchValidated(`${QUICKGO_BASE}/ontology/go/terms/${encodeURIComponent(goId)}`, GoTermResponseSchema, {
-                    headers: HEADERS,
-                });
-                if (res.isErr())
-                    throw new Error(`GO lookup: ${describeApiError(res.error)}`);
-                terms = res.value;
-            })());
-        }
-        if (query) {
-            tasks.push((async () => {
-                const params = new URLSearchParams({ query, limit: String(limit) });
-                const res = await apiFetchValidated(`${QUICKGO_BASE}/ontology/go/search?${params}`, GoTermResponseSchema, { headers: HEADERS });
-                if (res.isErr())
-                    throw new Error(`GO search: ${describeApiError(res.error)}`);
-                const searchTerms = res.value;
-                terms = terms ? [...terms, ...searchTerms] : searchTerms;
-            })());
-        }
-        if (geneProductId) {
-            tasks.push((async () => {
-                const params = new URLSearchParams({
-                    geneProductId,
-                    limit: String(limit),
-                });
-                if (taxonId)
-                    params.set("taxonId", String(taxonId));
-                const res = await apiFetchValidated(`${QUICKGO_BASE}/annotation/search?${params}`, GoAnnotationResponseSchema, { headers: HEADERS });
-                if (res.isErr())
-                    throw new Error(`Annotations: ${describeApiError(res.error)}`);
-                annotations = res.value;
-            })());
-        }
-        await Promise.all(tasks);
-        return ok({ terms, annotations });
-    },
-});

package/dist/tools/bio/search-bgee-expression.d.ts

@@ -1,10 +0,0 @@
-/**
- * searchBgeeExpression tool — cross-species baseline gene expression.
- */
-import { SUPPORTED_SPECIES, bucketRank, parseExpressionResponse } from "../lib/bgee-client.js";
-export type { SupportedSpecies } from "../lib/bgee-client.js";
-export { SUPPORTED_SPECIES, bucketRank, parseExpressionResponse };
-export declare const searchBgeeExpressionTool: import("../define-tool.js").Tool<{
-    geneSymbol: string;
-    species: ("homo_sapiens" | "mus_musculus" | "rattus_norvegicus" | "canis_lupus_familiaris" | "macaca_mulatta")[];
-}, import("../lib/bgee-client.js").MultiSpeciesExpression>;

package/dist/tools/bio/search-bgee-expression.js

@@ -1,30 +0,0 @@
-/**
- * searchBgeeExpression tool — cross-species baseline gene expression.
- */
-import { ok } from "neverthrow";
-import { z } from "zod";
-import { defineTool } from "../define-tool.js";
-import { SUPPORTED_SPECIES, bucketRank, getMultiSpeciesExpression, parseExpressionResponse } from "../lib/bgee-client.js";
-export { SUPPORTED_SPECIES, bucketRank, parseExpressionResponse };
-export const searchBgeeExpressionTool = defineTool({
-    id: "search_bgee_expression",
-    description: "Get BASELINE (healthy, untreated) gene expression across species from Bgee — use it to judge tissue-of-action ('where is this target expressed?') and model-organism " +
-        "suitability ('is the mouse a fair surrogate for this gene?'). " +
-        "NOT for differential expression between conditions — that is the analysis pipeline's job, never this tool. " +
-        "Takes a human gene symbol and resolves the per-species orthologs itself, returning a per-species tissue table: each tissue carries an expression score, a gold/silver confidence, " +
-        "an expressed / not-expressed state, and a bucketed rank (absent | low | medium | high). Species with no ortholog are listed in notFound. " +
-        "Sparse output is valid no-data: dog and macaque coverage is thin, and a null humanEnsemblId means the symbol did not resolve. Do NOT retry on empty output.",
-    inputSchema: z.object({
-        geneSymbol: z
-            .string()
-            .min(1)
-            .describe("HUMAN gene symbol, e.g. 'BRCA1' — one gene per call. Ensembl IDs and non-human symbols are not accepted; the human symbol is resolved to an ENSG and orthologs are looked up per species."),
-        species: z
-            .array(z.enum(SUPPORTED_SPECIES))
-            .min(1)
-            .default([...SUPPORTED_SPECIES])
-            .describe("Species to fetch, any subset of: homo_sapiens, mus_musculus, rattus_norvegicus, canis_lupus_familiaris, macaca_mulatta. " +
-            "Defaults to all five — narrow it only when the cross-species comparison is not needed."),
-    }),
-    execute: async ({ geneSymbol, species }) => ok(await getMultiSpeciesExpression(geneSymbol, species)),
-});

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

@@ -1,13 +0,0 @@
-/**
- * searchClinvar — search NCBI ClinVar for clinical significance of variants.
- */
-export declare function createSearchClinvarTool(deps: {
-    ncbiApiKey?: string;
-}): import("../define-tool.js").Tool<{
-    query: string;
-    limit: number;
-    clinicalSignificance?: "pathogenic" | "likely-pathogenic" | "benign" | "likely-benign" | "uncertain" | undefined;
-}, {
-    totalFound: number;
-    variants: import("../lib/clinvar-client.js").ClinvarVariant[];
-}>;

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

@@ -1,28 +0,0 @@
-/**
- * searchClinvar — search NCBI ClinVar for clinical significance of variants.
- */
-import { ok } from "neverthrow";
-import { z } from "zod";
-import { defineTool } from "../define-tool.js";
-import { searchClinvar } from "../lib/clinvar-client.js";
-export function createSearchClinvarTool(deps) {
-    return defineTool({
-        id: "search_clinvar",
-        description: "Search NCBI ClinVar for clinical significance of genetic variants. Returns pathogenicity classifications, associated conditions, and review status. Use to assess whether variants identified in omics data have known clinical significance.",
-        inputSchema: z.object({
-            query: z.string().describe("Gene symbol (e.g. BRCA1), variant (e.g. NM_007294.4:c.5266dupC), dbSNP rsID (e.g. rs80357906), or condition name"),
-            clinicalSignificance: z
-                .enum(["pathogenic", "likely-pathogenic", "benign", "likely-benign", "uncertain"])
-                .optional()
-                .describe("Filter by clinical significance"),
-            limit: z.number().int().min(1).max(100).default(20).describe("Max results to return"),
-        }),
-        execute: async ({ query, clinicalSignificance, limit = 20 }) => {
-            const { totalFound, variants } = await searchClinvar(deps.ncbiApiKey, query, {
-                clinicalSignificance,
-                limit,
-            });
-            return ok({ totalFound, variants });
-        },
-    });
-}

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

@@ -1,53 +0,0 @@
-/**
- * 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.
- */
-import type { Logger } from "../../lib/logger.js";
-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;
-    }[];
-}
-/**
- * A factory rather than a bare const (unlike its bio-leaf siblings) because it
- * logs: DGIdb answers GraphQL partial errors alongside usable data, and an
- * operator debugging odd interaction results needs to see them. `ToolContext`
- * carries no deps by design, so a tool that logs is dep-bearing — the same
- * reason `createSearchClinvarTool` takes its key that way.
- */
-export declare function createSearchDgidbTool(deps?: {
-    readonly logger?: Logger;
-}): 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 {};