@inflexa-ai/harness 0.1.1 → 0.2.0

package/dist/schemas/render-step-prompt.js

@@ -1,76 +0,0 @@
-/**
- * Render an AnalysisStep into the user-content prompt the sandbox agent
- * receives as its initial message.
- *
- * The planner writes the bulk of a step's instructions into structured
- * fields (`constraints`, `acceptance_criteria`, `context`, `caveats`,
- * `description`) alongside the one-line `question`. The execution path
- * forwards a single `prompt` string to the sandbox agent, so every
- * instruction-bearing field must be folded into that string here — otherwise
- * the agent runs against the bare question and improvises the rest.
- *
- * `STEP_PROMPT_INSTRUCTION_FIELDS` / `STEP_PROMPT_NON_INSTRUCTION_FIELDS`
- * partition every AnalysisStep field so the field-coverage guard test can
- * fail when a new field is added to the schema without a deliberate decision
- * about whether the agent needs to see it.
- */
-/** Fields whose content is agent-facing and MUST appear in the rendered prompt. */
-export const STEP_PROMPT_INSTRUCTION_FIELDS = [
-    "name",
-    "question",
-    "description",
-    "context",
-    "constraints",
-    "acceptance_criteria",
-    "caveats",
-];
-/**
- * Fields deliberately excluded from the prompt: identity/DAG structure
- * threaded separately through the workflow input, execution knobs, and
- * result fields populated after the step runs.
- */
-export const STEP_PROMPT_NON_INSTRUCTION_FIELDS = [
-    "id",
-    "track",
-    "step_type",
-    "depends_on",
-    "status",
-    "resources",
-    "agent",
-    "timeout",
-    "maxSteps",
-    "summary",
-    "artifactIds",
-    "error",
-];
-function section(heading, body) {
-    return `## ${heading}\n${body}`;
-}
-function bullets(items) {
-    return items.map((i) => `- ${i}`).join("\n");
-}
-/**
- * Compose the agent's initial prompt from a plan step. Only the `question`
- * is guaranteed present; the remaining instruction fields are appended as
- * dedicated sections when populated. Empty strings and empty arrays are
- * skipped so a sparse step renders cleanly.
- */
-export function renderStepPrompt(step) {
-    const parts = [`# ${step.name}`, section("Task", step.question)];
-    if (step.description?.trim()) {
-        parts.push(section("What this step produces", step.description.trim()));
-    }
-    if (step.context?.trim()) {
-        parts.push(section("Context", step.context.trim()));
-    }
-    if (step.constraints && step.constraints.length > 0) {
-        parts.push(section("Constraints (these are requirements, not suggestions — follow them exactly)", bullets(step.constraints)));
-    }
-    if (step.acceptance_criteria && step.acceptance_criteria.length > 0) {
-        parts.push(section("Acceptance criteria (the result must satisfy all of these)", bullets(step.acceptance_criteria)));
-    }
-    if (step.caveats && step.caveats.length > 0) {
-        parts.push(section("Caveats", bullets(step.caveats)));
-    }
-    return parts.join("\n\n");
-}

package/dist/tools/bio/find-approval-precedent.d.ts

@@ -1,32 +0,0 @@
-/**
- * findApprovalPrecedent — query openFDA / Drugs@FDA for prior approvals in a
- * given indication.
- */
-import { z } from "zod";
-export declare const findApprovalPrecedentInputSchema: z.ZodObject<{
-    indication: z.ZodString;
-    modality: z.ZodOptional<z.ZodEnum<{
-        small_molecule: "small_molecule";
-        biologic: "biologic";
-        gene_therapy: "gene_therapy";
-        cell_therapy: "cell_therapy";
-    }>>;
-    mechanism: z.ZodOptional<z.ZodString>;
-}, z.core.$strip>;
-interface Precedent {
-    application_number: string;
-    brand_name?: string;
-    generic_name?: string;
-    approval_date?: string;
-    label_section_excerpts?: Record<string, string>;
-}
-export declare const findApprovalPrecedent: import("../define-tool.js").Tool<{
-    indication: string;
-    modality?: "small_molecule" | "biologic" | "gene_therapy" | "cell_therapy" | undefined;
-    mechanism?: string | undefined;
-}, {
-    precedents: Precedent[];
-}>;
-/** Test-only — clears the in-memory cache to avoid cross-test bleed. */
-export declare function __resetApprovalPrecedentCacheForTest(): void;
-export {};

package/dist/tools/bio/find-approval-precedent.js

@@ -1,72 +0,0 @@
-/**
- * findApprovalPrecedent — query openFDA / Drugs@FDA for prior approvals in a
- * given indication.
- */
-import { ok } from "neverthrow";
-import { z } from "zod";
-import { defineTool } from "../define-tool.js";
-export const findApprovalPrecedentInputSchema = z.object({
-    indication: z.string().min(1).describe("Indication / disease name — searched against openFDA label.indications_and_usage"),
-    modality: z
-        .enum(["small_molecule", "biologic", "gene_therapy", "cell_therapy"])
-        .optional()
-        .describe("Optional modality hint (advisory; not used for filtering today)"),
-    mechanism: z.string().optional().describe("Optional MoA / mechanism hint (advisory; not used for filtering today)"),
-});
-const cache = new Map();
-const TTL_MS = 60 * 60 * 1000;
-export const findApprovalPrecedent = defineTool({
-    id: "find_approval_precedent",
-    description: "Query openFDA / Drugs@FDA for prior approvals in a given indication. Returns NDA/BLA application numbers, generic and brand names, approval dates (effective time of the label), and label-section excerpts (boxed warning, warnings and precautions, contraindications). Use to ground class-precedent claims and disposition framing in the executive recommendation.",
-    inputSchema: findApprovalPrecedentInputSchema,
-    execute: async ({ indication, modality, mechanism }) => {
-        const key = JSON.stringify({
-            indication: indication.toLowerCase(),
-            modality,
-            mechanism,
-        });
-        const cached = cache.get(key);
-        if (cached && Date.now() - cached.ts < TTL_MS)
-            return ok(cached.value);
-        const term = indication.replace(/"/g, "");
-        const url = new URL("https://api.fda.gov/drug/label.json");
-        url.searchParams.set("search", `indications_and_usage:"${term}"`);
-        url.searchParams.set("limit", "10");
-        const res = await fetch(url);
-        // openFDA answers a zero-match search with 404 — an expected "no
-        // precedents" outcome, not a failure. It is returned uncached so a
-        // later, more specific query is not masked. Any other non-ok status
-        // (5xx, 429) is an unexpected failure and throws.
-        if (res.status === 404)
-            return ok({ precedents: [] });
-        if (!res.ok) {
-            throw new Error(`openFDA label query failed: HTTP ${res.status}`);
-        }
-        const json = (await res.json());
-        const precedents = (json.results ?? []).slice(0, 10).map((r) => {
-            const excerpts = {};
-            if (r.boxed_warning?.[0])
-                excerpts.boxed_warning = r.boxed_warning[0].slice(0, 1000);
-            if (r.warnings_and_precautions?.[0])
-                excerpts.warnings_and_precautions = r.warnings_and_precautions[0].slice(0, 1000);
-            else if (r.warnings?.[0])
-                excerpts.warnings = r.warnings[0].slice(0, 1000);
-            if (r.contraindications?.[0])
-                excerpts.contraindications = r.contraindications[0].slice(0, 1000);
-            return {
-                application_number: r.openfda?.application_number?.[0] ?? "(unknown)",
-                brand_name: r.openfda?.brand_name?.[0],
-                generic_name: r.openfda?.generic_name?.[0],
-                approval_date: r.effective_time,
-                label_section_excerpts: Object.keys(excerpts).length > 0 ? excerpts : undefined,
-            };
-        });
-        const value = { precedents };
-        cache.set(key, { ts: Date.now(), value });
-        return ok(value);
-    },
-});
-/** Test-only — clears the in-memory cache to avoid cross-test bleed. */
-export function __resetApprovalPrecedentCacheForTest() {
-    cache.clear();
-}

package/dist/tools/bio/get-article-details.d.ts

@@ -1,11 +0,0 @@
-/**
- * getArticleDetails — fetch detailed metadata for PubMed articles.
- */
-export declare function createGetArticleDetailsTool(deps: {
-    ncbiApiKey?: string;
-}): import("../define-tool.js").Tool<{
-    pmids: string[];
-}, {
-    articles: import("../lib/ncbi-utils.js").ArticleDetail[];
-    notFound: string[];
-}>;

package/dist/tools/bio/get-article-details.js

@@ -1,20 +0,0 @@
-/**
- * getArticleDetails — fetch detailed metadata for PubMed articles.
- */
-import { ok } from "neverthrow";
-import { z } from "zod";
-import { defineTool } from "../define-tool.js";
-import { getArticleDetails } from "../lib/pubmed-client.js";
-export function createGetArticleDetailsTool(deps) {
-    return defineTool({
-        id: "get_article_details",
-        description: "Fetch detailed metadata for PubMed articles by PMID. " +
-            "Returns title, full abstract, authors, journal, year, DOI, MeSH terms, " +
-            "and PMC ID (if open-access full text is available in PubMed Central). " +
-            "Accepts up to 20 PMIDs per call for batch retrieval.",
-        inputSchema: z.object({
-            pmids: z.array(z.string()).min(1).max(20).describe("PubMed IDs to fetch details for (max 20)"),
-        }),
-        execute: async ({ pmids }) => ok(await getArticleDetails(deps.ncbiApiKey, pmids)),
-    });
-}

package/dist/tools/bio/get-article-full-text.d.ts

@@ -1,19 +0,0 @@
-/**
- * getArticleFullText — fetch full text of open-access articles from PMC.
- */
-import type { ArticleSection } from "../lib/ncbi-utils.js";
-type FullTextResult = {
-    pmcId: string;
-    available: false;
-} | {
-    pmcId: string;
-    available: true;
-    fullText: string;
-    sections: ArticleSection[];
-};
-export declare function createGetArticleFullTextTool(deps: {
-    ncbiApiKey?: string;
-}): import("../define-tool.js").Tool<{
-    pmcId: string;
-}, FullTextResult>;
-export {};

package/dist/tools/bio/get-article-full-text.js

@@ -1,32 +0,0 @@
-/**
- * getArticleFullText — fetch full text of open-access articles from PMC.
- */
-import { ok } from "neverthrow";
-import { z } from "zod";
-import { defineTool } from "../define-tool.js";
-import { getArticleFullText } from "../lib/pubmed-client.js";
-export function createGetArticleFullTextTool(deps) {
-    return defineTool({
-        id: "get_article_full_text",
-        description: "Fetch the full text of an open-access article from PubMed Central (PMC). " +
-            "Accepts a PMC ID (e.g., 'PMC1234567') as returned by getArticleDetails. " +
-            "Returns the article body as plain text with section headers preserved. " +
-            "Only works for open-access articles available in PMC — check the pmcId " +
-            "field from getArticleDetails before calling this tool.",
-        inputSchema: z.object({
-            pmcId: z.string().describe('PubMed Central ID (e.g., "PMC1234567")'),
-        }),
-        execute: async ({ pmcId }) => {
-            const parsed = await getArticleFullText(deps.ncbiApiKey, pmcId);
-            // "Not open-access" is an expected outcome — a data variant, not an error.
-            if (!parsed)
-                return ok({ pmcId, available: false });
-            return ok({
-                pmcId,
-                available: true,
-                fullText: parsed.fullText,
-                sections: parsed.sections,
-            });
-        },
-    });
-}

package/dist/tools/bio/get-bioactivity.d.ts

@@ -1,11 +0,0 @@
-/**
- * getBioactivity tool — retrieve bioactivity data (IC50, EC50, Ki) from ChEMBL.
- */
-export declare const getBioactivityTool: import("../define-tool.js").Tool<{
-    chemblId: string;
-    type: "target" | "compound";
-    limit: number;
-    activityType?: string | undefined;
-}, {
-    activities: import("../lib/chembl-client.js").ChemblActivity[];
-}>;

package/dist/tools/bio/get-bioactivity.js

@@ -1,23 +0,0 @@
-/**
- * getBioactivity tool — retrieve bioactivity data (IC50, EC50, Ki) from ChEMBL.
- */
-import { ok } from "neverthrow";
-import { z } from "zod";
-import { defineTool } from "../define-tool.js";
-import { getBioactivity } from "../lib/chembl-client.js";
-export const getBioactivityTool = defineTool({
-    id: "get_bioactivity",
-    description: "Get bioactivity data (IC50, EC50, Ki, etc.) from ChEMBL for a compound or target. " +
-        "Returns activity values, assay information, and pChEMBL values. " +
-        "Optionally filter by activity type (e.g. 'IC50', 'EC50', 'Ki').",
-    inputSchema: z.object({
-        chemblId: z.string().min(1).describe("ChEMBL ID (e.g. 'CHEMBL25' for aspirin, 'CHEMBL203' for EGFR target)"),
-        type: z.enum(["compound", "target"]).describe("Whether the ChEMBL ID refers to a compound or a target"),
-        activityType: z.string().optional().describe("Filter by standard_type (e.g. 'IC50', 'EC50', 'Ki')"),
-        limit: z.number().int().min(1).max(500).default(500).describe("Maximum number of activity records to return"),
-    }),
-    execute: async ({ chemblId, type, activityType, limit }) => {
-        const activities = await getBioactivity(chemblId, type, { activityType, limit });
-        return ok({ activities });
-    },
-});

package/dist/tools/bio/get-drug-info.d.ts

@@ -1,9 +0,0 @@
-/**
- * getDrugInfo tool — search ChEMBL for approved drugs by indication or name.
- */
-export declare const getDrugInfoTool: import("../define-tool.js").Tool<{
-    query: string;
-    limit: number;
-}, {
-    drugs: import("../lib/chembl-client.js").ChemblDrug[];
-}>;

package/dist/tools/bio/get-drug-info.js

@@ -1,22 +0,0 @@
-/**
- * getDrugInfo tool — search ChEMBL for approved drugs by indication or name.
- */
-import { ok } from "neverthrow";
-import { z } from "zod";
-import { defineTool } from "../define-tool.js";
-import { getDrugInfo } from "../lib/chembl-client.js";
-export const getDrugInfoTool = defineTool({
-    id: "get_drug_info",
-    description: "Search ChEMBL for approved drugs by indication or drug name. " +
-        "Returns drug metadata including approval phase, molecule type, " +
-        "first approval year, and indications. Falls back to molecule search " +
-        "filtered by max_phase >= 4 if the drug endpoint yields no results.",
-    inputSchema: z.object({
-        query: z.string().min(1).describe("Drug name or indication to search for (e.g. 'imatinib', 'breast cancer')"),
-        limit: z.number().int().min(1).max(25).default(25).describe("Maximum number of results to return"),
-    }),
-    execute: async ({ query, limit }) => {
-        const drugs = await getDrugInfo(query, limit);
-        return ok({ drugs });
-    },
-});

package/dist/tools/bio/get-mechanism.d.ts

@@ -1,8 +0,0 @@
-/**
- * getMechanism tool — retrieve mechanism of action data from ChEMBL.
- */
-export declare const getMechanismTool: import("../define-tool.js").Tool<{
-    chemblId: string;
-}, {
-    mechanisms: import("../lib/chembl-client.js").ChemblMechanism[];
-}>;

package/dist/tools/bio/get-mechanism.js

@@ -1,18 +0,0 @@
-/**
- * getMechanism tool — retrieve mechanism of action data from ChEMBL.
- */
-import { ok } from "neverthrow";
-import { z } from "zod";
-import { defineTool } from "../define-tool.js";
-import { getMechanism } from "../lib/chembl-client.js";
-export const getMechanismTool = defineTool({
-    id: "get_mechanism",
-    description: "Get mechanism of action for a compound from ChEMBL. " + "Returns mechanism descriptions, action types, and associated target information.",
-    inputSchema: z.object({
-        chemblId: z.string().min(1).describe("Compound ChEMBL ID (e.g. 'CHEMBL25' for aspirin)"),
-    }),
-    execute: async ({ chemblId }) => {
-        const mechanisms = await getMechanism(chemblId);
-        return ok({ mechanisms });
-    },
-});

package/dist/tools/bio/get-pubchem-assays.d.ts

@@ -1,22 +0,0 @@
-/**
- * getPubchemAssays tool — retrieve bioassay screening summaries for a PubChem CID.
- *
- * Returns per-assay activity outcomes (active/inactive/inconclusive),
- * target names, and assay descriptions. Broader coverage than ChEMBL's
- * curated bioactivity data.
- */
-interface Assay {
-    aid: number;
-    assayName: string | null;
-    targetName: string | null;
-    activityOutcome: string | null;
-    activityValue: number | null;
-}
-export declare const getPubchemAssaysTool: import("../define-tool.js").Tool<{
-    cid: number;
-    activeOnly: boolean;
-    limit: number;
-}, {
-    assays: Assay[];
-}>;
-export {};

package/dist/tools/bio/get-pubchem-assays.js

@@ -1,107 +0,0 @@
-/**
- * getPubchemAssays tool — retrieve bioassay screening summaries for a PubChem CID.
- *
- * Returns per-assay activity outcomes (active/inactive/inconclusive),
- * target names, and assay descriptions. Broader coverage than ChEMBL's
- * curated bioactivity data.
- */
-import { ok } from "neverthrow";
-import { z } from "zod";
-import { defineTool } from "../define-tool.js";
-import { apiFetchValidated, describeApiError } from "../lib/api-utils.js";
-import { PUBCHEM_HEADERS as HEADERS, PUBCHEM_BASE } from "../lib/pubchem-config.js";
-// The PUG-REST assay-summary wire shape (a table of columns + rows), validated
-// at the fetch boundary; `parseAssaySummary` maps the heading-indexed cells into
-// `Assay` records. Every field is optional — PubChem omits absent values.
-const PugAssaySummarySchema = z.object({
-    Table: z
-        .object({
-        Columns: z
-            .object({
-            Column: z.array(z.object({ Heading: z.string().optional() })).optional(),
-        })
-            .optional(),
-        Row: z
-            .array(z.object({
-            Cell: z
-                .array(z.object({
-                intval: z.number().optional(),
-                fval: z.number().optional(),
-                sval: z.string().optional(),
-            }))
-                .optional(),
-        }))
-            .optional(),
-    })
-        .optional(),
-});
-function parseAssaySummary(data) {
-    const columns = data.Table?.Columns?.Column ?? [];
-    const rows = data.Table?.Row ?? [];
-    // Find column indices by heading
-    const headingIndex = new Map();
-    for (let i = 0; i < columns.length; i++) {
-        if (columns[i].Heading) {
-            headingIndex.set(columns[i].Heading, i);
-        }
-    }
-    const aidIdx = headingIndex.get("AID");
-    const nameIdx = headingIndex.get("AssayName");
-    const targetIdx = headingIndex.get("TargetName");
-    const outcomeIdx = headingIndex.get("ActivityOutcome");
-    const valueIdx = headingIndex.get("ActivityValue");
-    const results = [];
-    for (const row of rows) {
-        const cells = row.Cell ?? [];
-        const getCellStr = (idx) => {
-            if (idx === undefined || idx >= cells.length)
-                return null;
-            return cells[idx]?.sval ?? null;
-        };
-        const getCellNum = (idx) => {
-            if (idx === undefined || idx >= cells.length)
-                return null;
-            const cell = cells[idx];
-            if (cell?.fval !== undefined)
-                return cell.fval;
-            if (cell?.intval !== undefined)
-                return cell.intval;
-            return null;
-        };
-        results.push({
-            aid: getCellNum(aidIdx) ?? 0,
-            assayName: getCellStr(nameIdx),
-            targetName: getCellStr(targetIdx),
-            activityOutcome: getCellStr(outcomeIdx),
-            activityValue: getCellNum(valueIdx),
-        });
-    }
-    return results;
-}
-export const getPubchemAssaysTool = defineTool({
-    id: "get_pubchem_assays",
-    description: "Get bioassay screening summaries for a PubChem CID. " +
-        "Returns per-assay activity outcomes (Active/Inactive/Inconclusive), target names, " +
-        "and activity values. Covers HTS screening data beyond ChEMBL's curated bioactivity. " +
-        "Use activeOnly=true to filter for active results only.",
-    inputSchema: z.object({
-        cid: z.number().int().positive().describe("PubChem Compound ID (CID)"),
-        activeOnly: z.boolean().default(false).describe("If true, return only assays where the compound was active"),
-        limit: z.number().int().min(1).max(500).default(50).describe("Maximum number of assay records to return"),
-    }),
-    execute: async ({ cid, activeOnly = false, limit = 50 }) => {
-        const url = `${PUBCHEM_BASE}/compound/cid/${cid}/assaysummary/JSON`;
-        const res = await apiFetchValidated(url, PugAssaySummarySchema, { headers: HEADERS });
-        if (res.isErr()) {
-            // PubChem returns 404 when the CID has no assay data — expected.
-            if (res.error.type === "http_status" && res.error.status === 404)
-                return ok({ assays: [] });
-            throw new Error(describeApiError(res.error));
-        }
-        let assays = parseAssaySummary(res.value);
-        if (activeOnly) {
-            assays = assays.filter((a) => a.activityOutcome?.toLowerCase() === "active");
-        }
-        return ok({ assays: assays.slice(0, limit) });
-    },
-});

package/dist/tools/bio/get-pubchem-cross-refs.d.ts

@@ -1,15 +0,0 @@
-/**
- * getPubchemCrossRefs tool — retrieve external database identifiers for a PubChem CID.
- *
- * Bridges PubChem compounds to ChEMBL, DrugBank, KEGG, PDB, and other registries.
- */
-interface CrossRefEntry {
-    source: string;
-    id: string;
-}
-export declare const getPubchemCrossRefsTool: import("../define-tool.js").Tool<{
-    cid: number;
-}, {
-    crossRefs: CrossRefEntry[];
-}>;
-export {};

package/dist/tools/bio/get-pubchem-cross-refs.js

@@ -1,68 +0,0 @@
-/**
- * getPubchemCrossRefs tool — retrieve external database identifiers for a PubChem CID.
- *
- * Bridges PubChem compounds to ChEMBL, DrugBank, KEGG, PDB, and other registries.
- */
-import { ok } from "neverthrow";
-import { z } from "zod";
-import { defineTool } from "../define-tool.js";
-import { apiFetchValidated, describeApiError } from "../lib/api-utils.js";
-import { PUBCHEM_HEADERS as HEADERS, PUBCHEM_BASE } from "../lib/pubchem-config.js";
-// The PUG-REST xrefs wire shape, validated at the fetch boundary: one
-// `Information` entry per CID with parallel `RegistryID[]` / `SourceName[]`
-// arrays. Every field is optional — PubChem omits absent values.
-const PubChemXrefResponseSchema = z.object({
-    InformationList: z
-        .object({
-        Information: z
-            .array(z.object({
-            CID: z.number().optional(),
-            RegistryID: z.array(z.string()).optional(),
-            SourceName: z.array(z.string()).optional(),
-        }))
-            .optional(),
-    })
-        .optional(),
-});
-function mapCrossRef(raw) {
-    return {
-        source: raw.SourceName ?? "Unknown",
-        id: raw.RegistryID ?? "",
-    };
-}
-export const getPubchemCrossRefsTool = defineTool({
-    id: "get_pubchem_cross_refs",
-    description: "Get external database cross-references for a PubChem CID. " +
-        "Returns linked identifiers from ChEMBL, DrugBank, KEGG, PDB, and other registries. " +
-        "Use this to bridge PubChem compounds to other databases (e.g., get ChEMBL ID to then " +
-        "query bioactivity via ChEMBL tools).",
-    inputSchema: z.object({
-        cid: z.number().int().positive().describe("PubChem Compound ID (CID)"),
-    }),
-    execute: async ({ cid }) => {
-        const url = `${PUBCHEM_BASE}/compound/cid/${cid}/xrefs/RegistryID,SourceName/JSON`;
-        const res = await apiFetchValidated(url, PubChemXrefResponseSchema, { headers: HEADERS });
-        if (res.isErr()) {
-            // PubChem returns 404 when the CID has no cross-references — expected.
-            if (res.error.type === "http_status" && res.error.status === 404)
-                return ok({ crossRefs: [] });
-            throw new Error(describeApiError(res.error));
-        }
-        // PUG-REST xrefs returns an InformationList with one entry per CID.
-        // Each entry has parallel RegistryID[] and SourceName[] arrays.
-        const info = res.value.InformationList?.Information?.[0];
-        if (!info?.RegistryID?.length) {
-            return ok({ crossRefs: [] });
-        }
-        const crossRefs = [];
-        const registryIds = info.RegistryID;
-        const sourceNames = info.SourceName ?? [];
-        for (let i = 0; i < registryIds.length; i++) {
-            crossRefs.push(mapCrossRef({
-                RegistryID: registryIds[i],
-                SourceName: sourceNames[i],
-            }));
-        }
-        return ok({ crossRefs });
-    },
-});

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

@@ -1,18 +0,0 @@
-/**
- * getTargetSafety — fetch known safety liabilities for a target from
- * Open Targets.
- */
-import { getTargetSafetyLiabilities } from "../lib/opentargets-client.js";
-type SafetyLiabilities = NonNullable<Awaited<ReturnType<typeof getTargetSafetyLiabilities>>>["safetyLiabilities"];
-type GetTargetSafetyOutput = {
-    found: false;
-    ensemblId: string;
-} | {
-    found: true;
-    targetSymbol: string;
-    safetyLiabilities: SafetyLiabilities;
-};
-export declare const getTargetSafetyTool: import("../define-tool.js").Tool<{
-    ensemblId: string;
-}, GetTargetSafetyOutput>;
-export {};

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

@@ -1,26 +0,0 @@
-/**
- * getTargetSafety — fetch known safety liabilities for a target from
- * Open Targets.
- */
-import { ok } from "neverthrow";
-import { z } from "zod";
-import { defineTool } from "../define-tool.js";
-import { getTargetSafetyLiabilities } from "../lib/opentargets-client.js";
-export const getTargetSafetyTool = defineTool({
-    id: "get_target_safety",
-    description: "Get known safety liabilities for a target from Open Targets. Returns organ-specific toxicity signals, adverse events, and safety-related phenotypes linked to the target.",
-    inputSchema: z.object({
-        ensemblId: z.string().describe("Ensembl gene ID (e.g. ENSG00000141510)"),
-    }),
-    execute: async ({ ensemblId }) => {
-        const result = await getTargetSafetyLiabilities(ensemblId);
-        // "Target not found" is an expected outcome — a data variant, not an error.
-        if (!result)
-            return ok({ found: false, ensemblId });
-        return ok({
-            found: true,
-            targetSymbol: result.targetSymbol,
-            safetyLiabilities: result.safetyLiabilities,
-        });
-    },
-});

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

@@ -1,22 +0,0 @@
-/**
- * searchCompounds tool — search ChEMBL for compounds by target, name, or SMILES.
- *
- * Supports three search modes:
- * - "target": resolves target ChEMBL ID, fetches activities, extracts unique molecules
- * - "compound": free-text search on molecule names
- * - "smiles": flexmatch on canonical SMILES
- */
-export declare const searchCompoundsTool: import("../define-tool.js").Tool<{
-    query: string;
-    searchType: "target" | "smiles" | "compound";
-    limit: number;
-}, {
-    compounds: {
-        chemblId: string;
-        preferredCompoundName: string | null;
-        canonicalSmiles: string | null;
-        molecularWeight: number | null;
-        alogp: number | null;
-        molecularFormula: string | null;
-    }[];
-}>;