@inflexa-ai/harness 0.13.0 → 0.14.1

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

@@ -10,14 +10,20 @@ export const searchFaersTool = defineTool({
     description: "Search FDA FAERS for post-market adverse-event reports on one marketed drug — the real-world safety signal for a specific molecule. " +
         "Returns totalReports and adverseEvents[]: { reaction (MedDRA preferred term), count }, most-reported first. " +
         "These are spontaneous report counts, NOT incidence rates: there is no denominator and reporting is heavily biased, so use them to rank signals, never to state a rate. " +
-        "Matching is on the openFDA GENERIC name only — 'imatinib' works, the brand name 'Gleevec' does not. For mechanism-based liabilities of a target (rather than a drug), use opentargets({action:\"safety\"}). " +
+        "Matching is on the openFDA GENERIC name only — 'imatinib' works, the brand name 'Gleevec' does not. For mechanism-based liabilities of a TARGET (rather than a marketed drug), use target_safety. " +
         "An empty adverseEvents array is valid no-data (drug absent from FAERS under that generic name) — do not retry.",
     inputSchema: z.object({
         drugName: z.string().describe("Generic (INN) drug name, e.g. 'imatinib', 'pembrolizumab'. Brand names do not match."),
-        limit: z.number().int().min(1).max(100).default(25).describe("Max distinct adverse-reaction terms to return (default 25, max 100)."),
+        limit: z
+            .number()
+            .int()
+            .min(1)
+            .max(100)
+            .default(15)
+            .describe("Max distinct adverse-reaction terms to return, most-reported first (default 15, max 100). totalReports covers the whole drug regardless."),
         serious: z.boolean().default(false).describe("When true, count only reports flagged serious (death, hospitalization, life-threatening, disabling)."),
     }),
-    execute: async ({ drugName, limit = 25, serious = false }) => {
+    execute: async ({ drugName, limit = 15, serious = false }) => {
         const result = await getFaersByDrug(drugName, { limit, serious });
         return ok({
             totalReports: result.totalReports,

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

@@ -4,7 +4,6 @@
 export declare const searchGeneTool: import("../define-tool.js").Tool<{
     symbols: string[];
     species: string;
-    expand: boolean;
 }, {
     genes: import("../lib/ensembl-client.js").GeneInfo[];
     notFound: string[];

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

@@ -7,13 +7,12 @@ import { defineTool } from "../define-tool.js";
 import { lookupGenes } from "../lib/ensembl-client.js";
 export const searchGeneTool = defineTool({
     id: "search_gene",
-    description: "Look up gene information from Ensembl by gene symbol. " +
-        "Returns Ensembl IDs, genomic coordinates, biotype, and descriptions. " +
-        "Supports batch lookups of up to 200 symbols at once.",
+    description: "Resolve gene symbols against Ensembl — the identifier step other tools depend on. Per symbol: Ensembl gene ID (ENSG…), coordinates, strand, " +
+        "biotype, assembly, description; plus notFound[]. Gene-level only — no transcripts or exons. Batch up to 200 symbols per call. " +
+        "notFound is valid no-data (deprecated, aliased or mistyped symbol, or wrong species) — do not retry unchanged.",
     inputSchema: z.object({
         symbols: z.array(z.string()).min(1).max(200).describe("Gene symbols to look up (e.g. ['BRCA1', 'TP53'])"),
         species: z.string().default("homo_sapiens").describe("Species name (e.g. 'homo_sapiens', 'mus_musculus')"),
-        expand: z.boolean().default(false).describe("Include transcript/exon details in the response"),
     }),
-    execute: async ({ symbols, species, expand }) => ok(await lookupGenes(symbols, { species, expand })),
+    execute: async ({ symbols, species }) => ok(await lookupGenes(symbols, { species })),
 });

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

@@ -39,7 +39,7 @@ const GeoEsummaryResponseSchema = z.object({
 export const searchGeoDatasetsTool = defineTool({
     id: "search_geo_datasets",
     description: "Search NCBI GEO for public gene-expression datasets by disease, tissue, or experimental condition — use it to find external validation cohorts or to cite published data. " +
-        "Returns totalFound plus datasets[]: { accession (GSE…/GDS…), title, summary (truncated to 500 chars), platform, sampleCount, organism, pubmedIds }. " +
+        "Returns totalFound plus datasets[]: { accession (GSE…/GDS…), title, summary (truncated to 300 chars), platform, sampleCount, organism, pubmedIds }. " +
         "HARD CAVEAT: this tool returns metadata only, and sandbox containers have no network — never plan an in-sandbox step that downloads a GEO dataset. " +
         "Bringing the data itself in is a capability of the surrounding environment, not of this tool: consult the tools you actually have rather than assuming it is possible or that it is not. " +
         "An empty datasets array is a valid 'nothing matched' — do not retry the identical query.",
@@ -55,9 +55,15 @@ export const searchGeoDatasetsTool = defineTool({
             .enum(["gds", "gse"])
             .default("gse")
             .describe("'gse' (default) — GEO Series: raw submitter-deposited studies, far more numerous. 'gds' — curated DataSets: fewer, but normalized and value-added."),
-        limit: z.number().int().min(1).max(50).default(15).describe("Max datasets to return (default 15, max 50)."),
+        limit: z
+            .number()
+            .int()
+            .min(1)
+            .max(50)
+            .default(10)
+            .describe("Max datasets to return (default 10, max 50). totalFound reports the true match count regardless."),
     }),
-    execute: async ({ query, organism, datasetType = "gse", limit = 15 }) => {
+    execute: async ({ query, organism, datasetType = "gse", limit = 10 }) => {
         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
@@ -87,7 +93,7 @@ export const searchGeoDatasetsTool = defineTool({
             return {
                 accession: r.accession ?? r.gse ?? `GDS${id}`,
                 title: r.title ?? "",
-                summary: (r.summary ?? "").slice(0, 500),
+                summary: (r.summary ?? "").slice(0, 300),
                 platform: r.gpl ?? r.platform ?? null,
                 sampleCount: r.n_samples ? Number(r.n_samples) : null,
                 organism: r.taxon ?? null,

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

@@ -1,16 +1,20 @@
 /**
  * searchInteractions — query protein-protein interactions via STRING DB.
  */
-import { getEnrichment, getInteractionPartners } from "../lib/string-client.js";
+import { type StringEnrichment, type StringInteraction } from "../lib/string-client.js";
 type InteractionsOutput = {
-    enrichment: Awaited<ReturnType<typeof getEnrichment>>;
+    enrichment: StringEnrichment[];
+    totalTerms: number;
 } | {
-    interactions: Awaited<ReturnType<typeof getInteractionPartners>>;
+    interactions: StringInteraction[];
+} | {
+    interactions: StringInteraction[];
+    totalEdges: number;
 };
 export declare const searchInteractionsTool: import("../define-tool.js").Tool<{
     identifiers: string[];
     species: number;
-    action: "partners" | "network" | "enrichment";
+    action: "enrichment" | "partners" | "network";
     minScore: number;
     limit: number;
 }, InteractionsOutput>;

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

@@ -5,27 +5,43 @@ import { ok } from "neverthrow";
 import { z } from "zod";
 import { defineTool } from "../define-tool.js";
 import { getEnrichment, getInteractionNetwork, getInteractionPartners } from "../lib/string-client.js";
+const DEFAULT_LIMIT = 20;
 export const searchInteractionsTool = defineTool({
     id: "search_interactions",
-    description: "Query protein-protein interactions from STRING DB. " +
-        "Actions: 'partners' finds interaction partners for proteins, " +
-        "'network' gets the full interaction network between listed proteins, " +
-        "'enrichment' returns functional enrichment analysis (GO, KEGG, Reactome).",
+    description: "Query STRING DB for protein-protein interactions and gene-set functional enrichment. " +
+        "'partners' — the one-hop interaction partners of the input proteins, score-sorted: 'what else does this protein work with?'. " +
+        "'network' — the interactions AMONG the input proteins only, no new nodes: 'is my gene set actually connected?'. " +
+        "'enrichment' — statistical over-representation of GO, KEGG, Reactome and Pfam terms in the input set, FDR-sorted: the enrichment TEST, as " +
+        "opposed to lookup_annotation, which just reads a vocabulary. " +
+        "`limit` applies to all three actions and defaults small: a network over N proteins grows with N² edges. `totalEdges` / `totalTerms` give the " +
+        "pre-trim counts. An empty result is valid no-data (unconnected set, no enriched term, unresolvable identifiers) — do not retry.",
     inputSchema: z.object({
         identifiers: z.array(z.string()).min(1).max(100).describe("Protein/gene identifiers (e.g. ['TP53', 'BRCA1'])"),
         species: z.number().int().default(9606).describe("NCBI Taxonomy ID (9606 = human, 10090 = mouse)"),
         action: z.enum(["partners", "network", "enrichment"]).default("partners").describe("Query type"),
-        minScore: z.number().int().min(0).max(1000).default(400).describe("Minimum confidence score (400=medium, 700=high, 900=highest)"),
-        limit: z.number().int().min(1).max(100).default(20).describe("Max interaction partners (partners action only)"),
+        minScore: z
+            .number()
+            .int()
+            .min(0)
+            .max(1000)
+            .default(400)
+            .describe("Minimum confidence score, 'partners' and 'network' only (400=medium, 700=high, 900=highest). Raise it to cut a large network down."),
+        limit: z
+            .number()
+            .int()
+            .min(1)
+            .max(500)
+            .default(DEFAULT_LIMIT)
+            .describe(`Max records returned — partners, network edges, or enriched terms depending on action (default ${DEFAULT_LIMIT}, max 500). ` +
+            "Rows are ordered best-first (score descending for interactions, FDR ascending for enrichment), so the default keeps the strongest."),
     }),
     execute: async ({ identifiers, species, action, minScore, limit }) => {
         if (action === "enrichment") {
-            const enrichment = await getEnrichment(identifiers, species);
-            return ok({ enrichment });
+            return ok(await getEnrichment(identifiers, species, { limit }));
         }
-        const interactions = action === "partners"
-            ? await getInteractionPartners(identifiers, { species, minScore, limit })
-            : await getInteractionNetwork(identifiers, { species, minScore });
-        return ok({ interactions });
+        if (action === "network") {
+            return ok(await getInteractionNetwork(identifiers, { species, minScore, limit }));
+        }
+        return ok({ interactions: await getInteractionPartners(identifiers, { species, minScore, limit }) });
     },
 });

package/dist/tools/bio/target-safety.d.ts

@@ -0,0 +1,59 @@
+/**
+ * targetSafety — target-level, mechanism-based safety liability from the two
+ * sources that carry it: the curated secondary-pharmacology panel that ships
+ * with the harness, and Open Targets' curated liabilities.
+ *
+ * These were `check_safety_panel` and `opentargets({action:'safety'})`, and the
+ * panel tool's own description instructed calling them together — a pairing
+ * every caller had to remember, expressed in prose that had already gone stale
+ * (it named two tools that no longer exist). Both are keyed on the same target
+ * and answer the same question, so the pairing belongs in the tool.
+ *
+ * Identifier resolution is the tool's job, not the caller's: Open Targets
+ * accepts ONLY an Ensembl gene id, and it is taken from the panel entry when
+ * there is one and resolved from the gene symbol when there is not.
+ */
+import { type SafetyTarget } from "../../data/safety-panel-schema.js";
+import { type SafetyLiability } from "../lib/opentargets-client.js";
+declare const SOURCES: readonly ["panel", "opentargets"];
+type Source = (typeof SOURCES)[number];
+type ConcreteType = "chembl_id" | "gene_symbol" | "uniprot" | "ensembl_id";
+interface TargetRow {
+    input: string;
+    identifierType: ConcreteType;
+    /** The Ensembl id Open Targets was queried with, when one could be obtained. */
+    ensemblId?: string;
+    panelEntry?: SafetyTarget | null;
+    liabilities?: SafetyLiability[];
+    /** Liabilities Open Targets held before `liabilityLimit` trimmed them. */
+    liabilityCount?: number;
+    /** Why the Open Targets half is absent for this identifier, when it is. */
+    opentargetsNote?: string;
+}
+interface SourceOutcome {
+    source: Source;
+    status: "ok" | "no_data" | "unavailable";
+    /** Identifiers this source returned something for. */
+    matched: number;
+    detail?: string;
+}
+export declare const targetSafetyTool: import("../define-tool.js").Tool<{
+    identifiers: string[];
+    identifierType?: "auto" | "gene_symbol" | "uniprot" | "chembl_id" | "ensembl_id" | undefined;
+    sources?: ("opentargets" | "panel")[] | undefined;
+    filterOrgan?: "hematologic" | "metabolic" | "immune" | "hepatic" | "cns" | "renal" | "respiratory" | "cardiac" | "gi" | undefined;
+    minSeverity?: "high" | "medium" | "low" | undefined;
+    liabilityLimit?: number | undefined;
+}, {
+    perSource: SourceOutcome[];
+    summary: {
+        totalInput: number;
+        panelMatched: number;
+        bySeverity: Record<"high" | "medium" | "low", number>;
+        byOrgan: Record<string, number>;
+        openTargetsWithLiabilities: number;
+    };
+    targets: TargetRow[];
+    panelVersion: string;
+}>;
+export {};

package/dist/tools/bio/target-safety.js

@@ -0,0 +1,191 @@
+/**
+ * targetSafety — target-level, mechanism-based safety liability from the two
+ * sources that carry it: the curated secondary-pharmacology panel that ships
+ * with the harness, and Open Targets' curated liabilities.
+ *
+ * These were `check_safety_panel` and `opentargets({action:'safety'})`, and the
+ * panel tool's own description instructed calling them together — a pairing
+ * every caller had to remember, expressed in prose that had already gone stale
+ * (it named two tools that no longer exist). Both are keyed on the same target
+ * and answer the same question, so the pairing belongs in the tool.
+ *
+ * Identifier resolution is the tool's job, not the caller's: Open Targets
+ * accepts ONLY an Ensembl gene id, and it is taken from the panel entry when
+ * there is one and resolved from the gene symbol when there is not.
+ */
+import { ok } from "neverthrow";
+import { z } from "zod";
+import { CHEMBL_RE, ORGAN_SYSTEMS, SEVERITIES, 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";
+import { resolveSymbolToEnsemblId } from "../lib/ensembl-client.js";
+import { getTargetSafetyLiabilities } from "../lib/opentargets-client.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]));
+const ENSG_RE = /^ENSG\d{11}$/;
+/** Ordered weakest → strongest so `minSeverity` can be a numeric floor. */
+const SEVERITY_ORDER = { low: 0, medium: 1, high: 2 };
+const SOURCES = ["panel", "opentargets"];
+/** Identifiers the panel can be swept for free; Open Targets costs a request each. */
+const MAX_PANEL_IDENTIFIERS = 200;
+const MAX_OPENTARGETS_IDENTIFIERS = 25;
+const DEFAULT_LIABILITY_LIMIT = 10;
+function detectType(id) {
+    if (CHEMBL_RE.test(id))
+        return "chembl_id";
+    if (ENSG_RE.test(id))
+        return "ensembl_id";
+    if (UNIPROT_RE.test(id))
+        return "uniprot";
+    return "gene_symbol";
+}
+function panelLookup(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;
+        case "ensembl_id":
+            return PANEL.targets.find((t) => t.ensembl_gene_id === id) ?? null;
+    }
+}
+const inputSchema = z
+    .object({
+    identifiers: z
+        .array(z.string().min(1))
+        .min(1)
+        .max(MAX_PANEL_IDENTIFIERS)
+        .describe(`Target identifiers, 1–${MAX_PANEL_IDENTIFIERS} — gene symbols, ChEMBL target IDs, UniProt accessions, or Ensembl gene IDs, mixed ` +
+        `freely. Capped at ${MAX_OPENTARGETS_IDENTIFIERS} when source 'opentargets' is included, since that source costs a request per target.`),
+    identifierType: z
+        .enum(["chembl_id", "gene_symbol", "uniprot", "ensembl_id", "auto"])
+        .optional()
+        .describe("Default 'auto', detecting per input by shape (CHEMBL…, ENSG…, UniProt accession, else a gene symbol). Set it only to force one reading."),
+    sources: z
+        .array(z.enum(SOURCES))
+        .min(1)
+        .optional()
+        .describe("Default BOTH — the panel is a local lookup with no request cost, and they cover different ground. " +
+        "'panel': the curated secondary-pharmacology panel — a fast first-pass off-target screen giving organ system, severity and clinical " +
+        "consequence with references. Finite and hand-curated, so absence is NOT evidence of safety. " +
+        "'opentargets': curated target liabilities — event, affected biosamples, direction of effect, source. Needs an Ensembl gene id, taken " +
+        "from the panel entry or resolved from the symbol for you."),
+    filterOrgan: z.enum(ORGAN_SYSTEMS).optional().describe("'panel' only. Keep only matches in this organ system, when screening one liability class."),
+    minSeverity: z.enum(SEVERITIES).optional().describe("'panel' only. Drop matches below this severity; default 'low'. Use 'high' to triage a large set."),
+    liabilityLimit: z
+        .number()
+        .int()
+        .min(1)
+        .max(100)
+        .optional()
+        .describe(`'opentargets' only. Max liabilities per target (default ${DEFAULT_LIABILITY_LIMIT}, max 100); \`liabilityCount\` gives the true total.`),
+})
+    .refine((d) => (d.sources ?? [...SOURCES]).includes("opentargets") === false || d.identifiers.length <= MAX_OPENTARGETS_IDENTIFIERS, {
+    message: `identifiers is capped at ${MAX_OPENTARGETS_IDENTIFIERS} when source 'opentargets' is included (one request per target). ` +
+        `Either narrow the list, or pass sources: ['panel'] to sweep up to ${MAX_PANEL_IDENTIFIERS} against the local panel first and follow up on the hits.`,
+    path: ["identifiers"],
+});
+export const targetSafetyTool = defineTool({
+    id: "target_safety",
+    description: "TARGET-level, mechanism-based safety liability — the curated secondary-pharmacology panel and Open Targets' curated liabilities in one call. " +
+        "Judges what engaging a target is likely to do to an organ system, before any specific molecule exists. Identifiers may be gene symbols, ChEMBL " +
+        "target IDs, UniProt accessions or Ensembl gene IDs, mixed.\n" +
+        "This is the safety of the TARGET, not of a drug. For a marketed molecule's post-market adverse events use search_faers; for a chemical's " +
+        "toxicology use comptox; for what removing the gene does in vivo use gene_preclinical_profile.\n" +
+        "ABSENCE IS NOT SAFETY. The panel is finite and hand-curated, so no match means only 'not on the panel'; an empty Open Targets liability list " +
+        "means no CURATED liability, not that none exists. Both are valid no-data — do not retry. Read `perSource` and each row's `opentargetsNote`: a " +
+        "ChEMBL or UniProt identifier absent from the panel cannot be resolved to an Ensembl id, so its Open Targets half is skipped rather than empty.",
+    inputSchema,
+    execute: async ({ identifiers, identifierType, sources, filterOrgan, minSeverity, liabilityLimit }) => {
+        const selected = sources ?? [...SOURCES];
+        const wantPanel = selected.includes("panel");
+        const wantOpenTargets = selected.includes("opentargets");
+        const severityFloor = SEVERITY_ORDER[minSeverity ?? "low"];
+        const limit = liabilityLimit ?? DEFAULT_LIABILITY_LIMIT;
+        const rows = identifiers.map((input) => {
+            const type = identifierType && identifierType !== "auto" ? identifierType : detectType(input);
+            const row = { input, identifierType: type };
+            if (wantPanel) {
+                const entry = panelLookup(input, type);
+                const organMatches = !entry || !filterOrgan || entry.organ_system === filterOrgan;
+                const severityMatches = !entry || SEVERITY_ORDER[entry.severity] >= severityFloor;
+                row.panelEntry = entry && organMatches && severityMatches ? entry : null;
+            }
+            return row;
+        });
+        let opentargetsError;
+        if (wantOpenTargets) {
+            await Promise.all(rows.map(async (row) => {
+                // Open Targets takes an ENSG only. The panel entry carries one for
+                // free; a gene symbol can be resolved; a ChEMBL or UniProt id that
+                // is not on the panel cannot, and is skipped explicitly.
+                const panelEnsembl = panelLookup(row.input, row.identifierType)?.ensembl_gene_id;
+                let ensemblId = row.identifierType === "ensembl_id" ? row.input : (panelEnsembl ?? null);
+                if (!ensemblId && row.identifierType === "gene_symbol") {
+                    ensemblId = await resolveSymbolToEnsemblId(row.input);
+                    if (!ensemblId) {
+                        row.opentargetsNote = "gene symbol did not resolve to an Ensembl gene id";
+                        return;
+                    }
+                }
+                if (!ensemblId) {
+                    row.opentargetsNote = `no Ensembl gene id available for a ${row.identifierType} that is not on the panel`;
+                    return;
+                }
+                row.ensemblId = ensemblId;
+                try {
+                    const result = await getTargetSafetyLiabilities(ensemblId);
+                    if (!result) {
+                        row.opentargetsNote = "no Open Targets record for this Ensembl gene id";
+                        return;
+                    }
+                    row.liabilityCount = result.safetyLiabilities.length;
+                    row.liabilities = result.safetyLiabilities.slice(0, limit);
+                }
+                catch (error) {
+                    opentargetsError = error instanceof Error ? error.message : String(error);
+                    row.opentargetsNote = "Open Targets could not be reached";
+                }
+            }));
+        }
+        const bySeverity = { high: 0, medium: 0, low: 0 };
+        const byOrgan = {};
+        let panelMatched = 0;
+        for (const row of rows) {
+            if (!row.panelEntry)
+                continue;
+            panelMatched++;
+            bySeverity[row.panelEntry.severity]++;
+            byOrgan[row.panelEntry.organ_system] = (byOrgan[row.panelEntry.organ_system] ?? 0) + 1;
+        }
+        const withLiabilities = rows.filter((r) => (r.liabilities?.length ?? 0) > 0).length;
+        const perSource = [];
+        if (wantPanel) {
+            perSource.push({ source: "panel", status: panelMatched > 0 ? "ok" : "no_data", matched: panelMatched });
+        }
+        if (wantOpenTargets) {
+            perSource.push({
+                source: "opentargets",
+                status: opentargetsError ? "unavailable" : withLiabilities > 0 ? "ok" : "no_data",
+                matched: withLiabilities,
+                ...(opentargetsError ? { detail: opentargetsError } : {}),
+            });
+        }
+        return ok({
+            perSource,
+            summary: {
+                totalInput: identifiers.length,
+                panelMatched,
+                bySeverity,
+                byOrgan: byOrgan,
+                openTargetsWithLiabilities: withLiabilities,
+            },
+            targets: rows,
+            panelVersion: PANEL.panel_version,
+        });
+    },
+});

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

@@ -39,5 +39,6 @@ export declare function createExecuteAnalysisTool(deps: ExecuteAnalysisToolDeps)
     request?: string | undefined;
 }, {
     runId: string;
+    status: "in_progress";
 }>;
 export {};

package/dist/tools/execute-analysis.js

@@ -150,7 +150,7 @@ export function createExecuteAnalysisTool(deps) {
         description: "Launch analysis computation asynchronously. Use mode=plan with the planId only after the user approved that stored plan. " +
             "Use mode=adhoc with the user's exact targeted computational request when they explicitly asked to run/compute/test/compare it; " +
             "that explicit request is consent and needs no synthetic-plan approval. If computation is merely your suggestion, ask first. " +
-            "You never choose the sandbox specialist: ad hoc routing does that automatically. Returns runId; inspect results on a later turn.",
+            "You never choose the sandbox specialist: ad hoc routing does that automatically. Returns runId with status=in_progress; inspect results on a later turn.",
         inputSchema,
         execute: async (input, ctx) => {
             if (ctx.session.scope.kind !== "analysis")
@@ -174,7 +174,7 @@ export function createExecuteAnalysisTool(deps) {
                 const active = unwrapOrThrow(await queryActiveRun(deps.pool, analysisId, planId));
                 if (active) {
                     await emitRunCard(active.runId);
-                    return ok({ runId: active.runId });
+                    return ok({ runId: active.runId, status: "in_progress" });
                 }
             }
             else {
@@ -196,7 +196,7 @@ export function createExecuteAnalysisTool(deps) {
                         const active = unwrapOrThrow(await queryActiveRun(deps.pool, analysisId, planId));
                         if (active) {
                             await emitRunCard(active.runId);
-                            return ok({ runId: active.runId });
+                            return ok({ runId: active.runId, status: "in_progress" });
                         }
                     }
                     throw error;
@@ -212,7 +212,7 @@ export function createExecuteAnalysisTool(deps) {
                 }));
                 if (!reservation.inserted) {
                     await emitRunCard(reservation.row.runId);
-                    return ok({ runId: reservation.row.runId });
+                    return ok({ runId: reservation.row.runId, status: "in_progress" });
                 }
             }
             let authorization;
@@ -246,7 +246,7 @@ export function createExecuteAnalysisTool(deps) {
             }
             logger.info("analysis launched", { analysisId, runId, planId, mode: input.mode });
             await emitRunCard(runId);
-            return ok({ runId });
+            return ok({ runId, status: "in_progress" });
         },
     });
 }

package/dist/tools/lib/dgidb-client.d.ts

@@ -0,0 +1,49 @@
+/**
+ * Pure async client functions for the Drug-Gene Interaction Database (DGIdb)
+ * GraphQL API. Free, no key required.
+ *
+ * DGIdb aggregates 30+ sources (ChEMBL, DrugBank, TTD, PharmGKB,
+ * GuideToPharmacology, CIViC, …) and reports per-interaction source counts,
+ * which the caller uses as a confidence signal.
+ */
+export interface DgidbInteraction {
+    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 interface DgidbResult {
+    input: string;
+    found: boolean;
+    interactions: DgidbInteraction[];
+    /** Interactions this input had before `limit` trimmed them. */
+    totalInteractions: number;
+}
+export interface DgidbFilters {
+    interactionTypes?: string[];
+    sourceDbs?: string[];
+    minSources?: number;
+    includeAttributes?: boolean;
+    limit?: number;
+}
+/**
+ * Query DGIdb for interactions of the given genes or drugs.
+ *
+ * `onPartialErrors` receives GraphQL partial errors that arrive alongside
+ * usable data — the client itself never logs, so the caller decides.
+ */
+export declare function searchDgidb(inputs: string[], searchType: "gene" | "drug", filters?: DgidbFilters, onPartialErrors?: (errors: {
+    message?: string;
+}[]) => void): Promise<DgidbResult[]>;