@inflexa-ai/harness 0.1.1

package/dist/tools/lib/openfda-client.js

@@ -0,0 +1,192 @@
+/**
+ * Pure async client functions for the openFDA FAERS adverse-event API.
+ *
+ * Used by §2.6.2 (FAERS summary) and §2.6.6 (class precedent — drugs-in-class
+ * AEs).
+ */
+import { z } from "zod";
+import { apiFetchValidated, describeApiError } from "./api-utils.js";
+import { OPENFDA_BASE, OPENFDA_LABEL_BASE } from "./openfda-config.js";
+// FAERS count/meta wire shapes, validated at the fetch boundary. Every field is
+// optional — the API omits absent values, and graceful degradation relies on a
+// partial-but-valid payload still parsing.
+const FaersCountResponseSchema = z.object({
+    results: z.array(z.object({ term: z.string().optional(), count: z.number().optional() })).optional(),
+});
+const FaersMetaResponseSchema = z.object({
+    meta: z.object({ results: z.object({ total: z.number().optional() }).optional() }).optional(),
+});
+/** openFDA drug-label metadata block (`openfda`) — all fields free-form JSON. */
+const OpenFdaLabelMetaSchema = z.object({
+    application_number: z.unknown().optional(),
+    brand_name: z.unknown().optional(),
+    generic_name: z.unknown().optional(),
+});
+/** A single openFDA structured-product-label record (raw wire shape). */
+const OpenFdaLabelSchema = z.object({
+    set_id: z.unknown().optional(),
+    openfda: OpenFdaLabelMetaSchema.optional(),
+    effective_time: z.unknown().optional(),
+    boxed_warning: z.unknown().optional(),
+    warnings_and_cautions: z.unknown().optional(),
+    warnings: z.unknown().optional(),
+    rems_summary: z.unknown().optional(),
+    rems_indication: z.unknown().optional(),
+    medication_guide: z.unknown().optional(),
+});
+function buildSearch(drugName, serious) {
+    const escaped = drugName.replace(/"/g, '\\"');
+    let search = `patient.drug.openfda.generic_name:"${escaped}"`;
+    if (serious)
+        search += "+AND+serious:1";
+    return search;
+}
+/** Top adverse-reaction terms by count for a generic drug name. */
+export async function getFaersByDrug(drugName, options = {}) {
+    const limit = options.limit ?? 25;
+    const serious = options.serious ?? false;
+    const search = buildSearch(drugName, serious);
+    const countUrl = `${OPENFDA_BASE}?search=${encodeURIComponent(search)}` + `&count=patient.reaction.reactionmeddrapt.exact&limit=${limit}`;
+    const res = await apiFetchValidated(countUrl, FaersCountResponseSchema);
+    if (res.isErr()) {
+        if (res.error.type === "http_status" && res.error.status === 404)
+            return { totalReports: 0, adverseEvents: [] };
+        throw new Error(describeApiError(res.error));
+    }
+    const adverseEvents = (res.value?.results ?? []).map((r) => ({
+        reaction: r.term ?? "Unknown",
+        count: r.count ?? 0,
+    }));
+    const totalUrl = `${OPENFDA_BASE}?search=${encodeURIComponent(search)}&limit=1`;
+    const totalRes = await apiFetchValidated(totalUrl, FaersMetaResponseSchema);
+    const totalReports = totalRes.isOk() ? totalRes.value?.meta?.results?.total : undefined;
+    return { totalReports, adverseEvents };
+}
+/**
+ * Seriousness breakdown for a drug. Aggregates the seriousness flags
+ * (death, hospitalization, life-threatening, disabling) used by §2.6.2 fatal
+ * and §2.6.8 risk summary.
+ */
+export async function getFaersSeriousness(drugName) {
+    const escaped = drugName.replace(/"/g, '\\"');
+    const search = `patient.drug.openfda.generic_name:"${escaped}"`;
+    const totalUrl = `${OPENFDA_BASE}?search=${encodeURIComponent(search)}&limit=1`;
+    const totalRes = await apiFetchValidated(totalUrl, FaersMetaResponseSchema);
+    if (totalRes.isErr()) {
+        if (totalRes.error.type === "http_status" && totalRes.error.status === 404)
+            return null;
+        throw new Error(describeApiError(totalRes.error));
+    }
+    const totalReports = totalRes.value?.meta?.results?.total ?? 0;
+    if (totalReports === 0) {
+        return {
+            totalReports: 0,
+            fatalCount: 0,
+            hospitalizationCount: 0,
+            lifeThreateningCount: 0,
+            disablingCount: 0,
+            congenitalAnomalyCount: 0,
+            otherSeriousCount: 0,
+        };
+    }
+    async function countWith(field) {
+        const q = `${search}+AND+${field}:1`;
+        const url = `${OPENFDA_BASE}?search=${encodeURIComponent(q)}&limit=1`;
+        const res = await apiFetchValidated(url, FaersMetaResponseSchema);
+        if (res.isErr())
+            return 0;
+        return res.value?.meta?.results?.total ?? 0;
+    }
+    const [fatal, hosp, lifeT, dis, cong, other] = await Promise.all([
+        countWith("seriousnessdeath"),
+        countWith("seriousnesshospitalization"),
+        countWith("seriousnesslifethreatening"),
+        countWith("seriousnessdisabling"),
+        countWith("seriousnesscongenitalanomali"),
+        countWith("seriousnessother"),
+    ]);
+    return {
+        totalReports,
+        fatalCount: fatal,
+        hospitalizationCount: hosp,
+        lifeThreateningCount: lifeT,
+        disablingCount: dis,
+        congenitalAnomalyCount: cong,
+        otherSeriousCount: other,
+    };
+}
+function firstString(value) {
+    if (Array.isArray(value)) {
+        const first = value.find((v) => typeof v === "string" && v.trim());
+        return typeof first === "string" ? first : null;
+    }
+    if (typeof value === "string")
+        return value || null;
+    return null;
+}
+function joinSection(value) {
+    if (Array.isArray(value)) {
+        const parts = value.filter((v) => typeof v === "string" && v.trim().length > 0);
+        if (parts.length === 0)
+            return null;
+        return parts.join("\n\n");
+    }
+    if (typeof value === "string" && value.trim())
+        return value;
+    return null;
+}
+/**
+ * Build a stable, citable URL for an FDA structured product label. Prefers
+ * the DailyMed `setid` URL (canonical reference), falls back to a search URL
+ * keyed by application number when only that is available.
+ */
+function buildLabelSourceUrl(label) {
+    const setId = typeof label?.set_id === "string" ? label.set_id : null;
+    if (setId)
+        return `https://dailymed.nlm.nih.gov/dailymed/drugInfo.cfm?setid=${setId}`;
+    const appNum = firstString(label?.openfda?.application_number);
+    if (appNum) {
+        return `https://www.accessdata.fda.gov/scripts/cder/daf/index.cfm?event=overview.process&ApplNo=${encodeURIComponent(appNum)}`;
+    }
+    return "https://www.accessdata.fda.gov/scripts/cder/daf/";
+}
+function mapLabel(raw) {
+    const openfda = raw?.openfda ?? {};
+    const remsTextCandidates = [raw?.rems_summary, raw?.rems_indication, raw?.medication_guide];
+    const hasRems = remsTextCandidates.some((v) => joinSection(v) !== null) || (joinSection(raw?.boxed_warning)?.toLowerCase().includes("rems") ?? false);
+    return {
+        applicationNumber: firstString(openfda.application_number),
+        brandName: firstString(openfda.brand_name),
+        genericName: firstString(openfda.generic_name),
+        effectiveTime: typeof raw?.effective_time === "string" ? raw.effective_time : null,
+        boxedWarning: joinSection(raw?.boxed_warning),
+        warningsAndCautions: joinSection(raw?.warnings_and_cautions) ?? joinSection(raw?.warnings),
+        hasRems,
+        sourceUrl: buildLabelSourceUrl(raw),
+    };
+}
+// The label endpoint's records are mapped to `DrugLabelAction` rows by
+// `mapLabel` — a context-free normalize folded into the schema so ONE schema
+// validates the raw wire AND emits the output rows.
+const OpenFdaLabelResponseSchema = z.object({
+    results: z.array(OpenFdaLabelSchema.transform(mapLabel)).optional(),
+});
+/**
+ * Fetch FDA Structured Product Label entries by generic drug name. Returns
+ * the most recent N labels (sorted by effective_time desc); each row carries
+ * the boxed-warning text, the Section 5 warnings_and_cautions excerpt, and a
+ * REMS indicator. Returns [] on 404 / no match.
+ */
+export async function getDrugLabelActions(genericName, options = {}) {
+    const limit = options.limit ?? 5;
+    const escaped = genericName.replace(/"/g, '\\"');
+    const search = `openfda.generic_name:"${escaped}"`;
+    const url = `${OPENFDA_LABEL_BASE}?search=${encodeURIComponent(search)}` + `&sort=effective_time:desc&limit=${limit}`;
+    const res = await apiFetchValidated(url, OpenFdaLabelResponseSchema);
+    if (res.isErr()) {
+        if (res.error.type === "http_status" && res.error.status === 404)
+            return [];
+        throw new Error(describeApiError(res.error));
+    }
+    return res.value.results ?? [];
+}

package/dist/tools/lib/openfda-config.d.ts

@@ -0,0 +1,2 @@
+export declare const OPENFDA_BASE = "https://api.fda.gov/drug/event.json";
+export declare const OPENFDA_LABEL_BASE = "https://api.fda.gov/drug/label.json";

package/dist/tools/lib/openfda-config.js

@@ -0,0 +1,2 @@
+export const OPENFDA_BASE = "https://api.fda.gov/drug/event.json";
+export const OPENFDA_LABEL_BASE = "https://api.fda.gov/drug/label.json";

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

@@ -0,0 +1,64 @@
+/**
+ * Pure async client functions for the Open Targets Platform GraphQL API.
+ *
+ * Used directly by target-assessment workflow steps and by tool wrappers.
+ */
+export interface Association {
+    diseaseId: string;
+    diseaseName: string;
+    targetId?: string;
+    targetSymbol?: string;
+    targetName?: string;
+    score: number;
+    geneticAssociationScore: number | null;
+    knownDrugScore: number | null;
+    literatureScore: number | null;
+    animalModelScore: number | null;
+    somaticMutationScore: number | null;
+    literaturePmids: string[];
+}
+export interface TargetTractability {
+    smallMolecule: boolean | null;
+    antibody: boolean | null;
+    otherModalities: boolean | null;
+}
+export interface TargetInfo {
+    ensemblId: string;
+    approvedSymbol: string;
+    approvedName: string;
+    tractability: TargetTractability | null;
+    associations: Association[];
+}
+export interface SafetyLiability {
+    event: string;
+    biosamples: string[];
+    effects: string | null;
+    source: string;
+}
+export interface BaselineExpressionEntry {
+    tissueId: string;
+    tissueLabel: string;
+    organSystem: string | null;
+    rna: {
+        value: number;
+        unit: string;
+    } | null;
+    protein: {
+        level: number | null;
+    } | null;
+}
+/** Fetch target info, tractability, and disease associations for an Ensembl gene id. */
+export declare function searchTargetAssociations(ensemblId: string, limit?: number): Promise<TargetInfo | null>;
+/** Fetch target associations for a disease (EFO id). */
+export declare function searchDiseaseAssociations(efoId: string, limit?: number): Promise<Association[]>;
+/** Fetch known safety liabilities for a target. */
+export declare function getTargetSafetyLiabilities(ensemblId: string): Promise<{
+    targetSymbol: string;
+    safetyLiabilities: SafetyLiability[];
+} | null>;
+/**
+ * Fetch baseline RNA/protein expression across tissues. Open Targets
+ * exposes per-tissue expression with organ system tags — used by §2.7
+ * (Off-Tissue Risk) and §3.9 (Normal Tissue Expression).
+ */
+export declare function getBaselineExpression(ensemblId: string): Promise<BaselineExpressionEntry[]>;

package/dist/tools/lib/opentargets-client.js

@@ -0,0 +1,290 @@
+/**
+ * Pure async client functions for the Open Targets Platform GraphQL API.
+ *
+ * Used directly by target-assessment workflow steps and by tool wrappers.
+ */
+import { z } from "zod";
+import { apiFetchValidated, describeApiError } from "./api-utils.js";
+import { OT_GRAPHQL, OT_HEADERS } from "./opentargets-config.js";
+const TARGET_QUERY = `
+  query TargetAssociations($ensemblId: String!, $size: Int!) {
+    target(ensemblId: $ensemblId) {
+      id
+      approvedSymbol
+      approvedName
+      tractability {
+        label
+        modality
+        value
+      }
+    }
+    associations: target(ensemblId: $ensemblId) {
+      associatedDiseases(page: { size: $size, index: 0 }) {
+        rows {
+          disease { id name }
+          score
+          datatypeScores {
+            id
+            score
+          }
+        }
+      }
+    }
+  }
+`;
+const DISEASE_QUERY = `
+  query DiseaseAssociations($efoId: String!, $size: Int!) {
+    disease(efoId: $efoId) {
+      id
+      name
+      associatedTargets(page: { size: $size, index: 0 }) {
+        rows {
+          target { id approvedSymbol approvedName }
+          score
+          datatypeScores {
+            id
+            score
+          }
+        }
+      }
+    }
+  }
+`;
+const SAFETY_QUERY = `
+  query TargetSafety($ensemblId: String!) {
+    target(ensemblId: $ensemblId) {
+      id
+      approvedSymbol
+      safetyLiabilities {
+        event
+        biosamples { tissueLabel }
+        effects { direction }
+        datasource
+        literature
+        url
+      }
+    }
+  }
+`;
+const EXPRESSION_QUERY = `
+  query TargetExpression($ensemblId: String!) {
+    target(ensemblId: $ensemblId) {
+      id
+      approvedSymbol
+      expressions {
+        tissue {
+          id
+          label
+          organs
+        }
+        rna { value unit }
+        protein { level }
+      }
+    }
+  }
+`;
+// Open Targets GraphQL `data` payload schemas, validated at the fetch boundary.
+// Fields the mapping code reads behind a guard (optional chaining, `?? default`,
+// `Array.isArray`) are `.nullable().optional()`; fields read directly — a missing
+// value would otherwise mis-map — stay required so a contract break surfaces as
+// `invalid_response` instead of silently producing garbage. Nullable matters
+// because GraphQL returns an explicit `null` (not omission) for a nullable root
+// that resolves empty — an unknown/retired id yields `{"target": null}`, which a
+// bare `.optional()` rejects, turning a clean "not found" into a thrown error.
+const DatatypeScoreSchema = z.object({ id: z.string().optional(), score: z.number().optional() });
+const TargetAssociationsDataSchema = z.object({
+    target: z
+        .object({
+        id: z.string(),
+        approvedSymbol: z.string(),
+        approvedName: z.string(),
+        tractability: z
+            .array(z.object({ label: z.string().optional(), modality: z.string().optional(), value: z.boolean().optional() }))
+            .nullable()
+            .optional(),
+    })
+        .nullable()
+        .optional(),
+    associations: z
+        .object({
+        associatedDiseases: z
+            .object({
+            rows: z
+                .array(z.object({
+                disease: z.object({ id: z.string(), name: z.string() }),
+                score: z.number(),
+                datatypeScores: z.array(DatatypeScoreSchema).nullable().optional(),
+            }))
+                .nullable()
+                .optional(),
+        })
+            .optional(),
+    })
+        .nullable()
+        .optional(),
+});
+const DiseaseAssociationsDataSchema = z.object({
+    disease: z
+        .object({
+        id: z.string().optional(),
+        name: z.string().optional(),
+        associatedTargets: z
+            .object({
+            rows: z
+                .array(z.object({
+                target: z
+                    .object({ id: z.string().optional(), approvedSymbol: z.string().optional(), approvedName: z.string().optional() })
+                    .nullable()
+                    .optional(),
+                score: z.number(),
+                datatypeScores: z.array(DatatypeScoreSchema).nullable().optional(),
+            }))
+                .nullable()
+                .optional(),
+        })
+            .optional(),
+    })
+        .nullable()
+        .optional(),
+});
+const TargetSafetyDataSchema = z.object({
+    target: z
+        .object({
+        id: z.string().optional(),
+        approvedSymbol: z.string(),
+        safetyLiabilities: z
+            .array(z.object({
+            event: z.string().nullable().optional(),
+            biosamples: z
+                .array(z.object({ tissueLabel: z.string().nullable().optional() }))
+                .nullable()
+                .optional(),
+            effects: z
+                .array(z.object({ direction: z.string().nullable().optional() }))
+                .nullable()
+                .optional(),
+            datasource: z.string().nullable().optional(),
+        }))
+            .nullable()
+            .optional(),
+    })
+        .nullable()
+        .optional(),
+});
+const TargetExpressionDataSchema = z.object({
+    target: z
+        .object({
+        expressions: z
+            .array(z.object({
+            tissue: z.object({ id: z.string(), label: z.string(), organs: z.array(z.string()).nullable().optional() }),
+            rna: z.object({ value: z.number().nullable().optional(), unit: z.string().nullable().optional() }).nullable().optional(),
+            protein: z.object({ level: z.number().nullable().optional() }).nullable().optional(),
+        }))
+            .nullable()
+            .optional(),
+    })
+        .nullable()
+        .optional(),
+});
+function extractDatatype(datatypeScores, id) {
+    const match = datatypeScores.find((d) => d.id === id);
+    return match?.score ?? null;
+}
+async function gqlFetch(query, variables, schema) {
+    const res = await apiFetchValidated(OT_GRAPHQL, z.object({ data: schema.optional() }), {
+        method: "POST",
+        headers: OT_HEADERS,
+        body: JSON.stringify({ query, variables }),
+    });
+    if (res.isErr())
+        throw new Error(describeApiError(res.error));
+    if (!res.value.data)
+        throw new Error("Open Targets returned no data");
+    return res.value.data;
+}
+/** Fetch target info, tractability, and disease associations for an Ensembl gene id. */
+export async function searchTargetAssociations(ensemblId, limit = 25) {
+    const data = await gqlFetch(TARGET_QUERY, { ensemblId, size: limit }, TargetAssociationsDataSchema);
+    const target = data.target;
+    if (!target)
+        return null;
+    const tractabilityEntries = target.tractability ?? [];
+    const tractability = {
+        smallMolecule: tractabilityEntries.find((t) => t.modality === "SM")?.value ?? null,
+        antibody: tractabilityEntries.find((t) => t.modality === "AB")?.value ?? null,
+        otherModalities: tractabilityEntries.find((t) => t.modality === "OC")?.value ?? null,
+    };
+    const rows = data.associations?.associatedDiseases?.rows ?? [];
+    const associations = rows.map((row) => ({
+        diseaseId: row.disease.id,
+        diseaseName: row.disease.name,
+        score: row.score,
+        geneticAssociationScore: extractDatatype(row.datatypeScores ?? [], "genetic_association"),
+        knownDrugScore: extractDatatype(row.datatypeScores ?? [], "known_drug"),
+        literatureScore: extractDatatype(row.datatypeScores ?? [], "literature"),
+        animalModelScore: extractDatatype(row.datatypeScores ?? [], "animal_model"),
+        somaticMutationScore: extractDatatype(row.datatypeScores ?? [], "somatic_mutation"),
+        literaturePmids: [],
+    }));
+    return {
+        ensemblId: target.id,
+        approvedSymbol: target.approvedSymbol,
+        approvedName: target.approvedName,
+        tractability,
+        associations,
+    };
+}
+/** Fetch target associations for a disease (EFO id). */
+export async function searchDiseaseAssociations(efoId, limit = 25) {
+    const data = await gqlFetch(DISEASE_QUERY, { efoId, size: limit }, DiseaseAssociationsDataSchema);
+    const rows = data.disease?.associatedTargets?.rows ?? [];
+    return rows.map((row) => ({
+        diseaseId: efoId,
+        diseaseName: data.disease?.name ?? efoId,
+        targetId: row.target?.id ?? "",
+        targetSymbol: row.target?.approvedSymbol ?? "",
+        targetName: row.target?.approvedName ?? "",
+        score: row.score,
+        geneticAssociationScore: extractDatatype(row.datatypeScores ?? [], "genetic_association"),
+        knownDrugScore: extractDatatype(row.datatypeScores ?? [], "known_drug"),
+        literatureScore: extractDatatype(row.datatypeScores ?? [], "literature"),
+        animalModelScore: extractDatatype(row.datatypeScores ?? [], "animal_model"),
+        somaticMutationScore: extractDatatype(row.datatypeScores ?? [], "somatic_mutation"),
+        literaturePmids: [],
+    }));
+}
+/** Fetch known safety liabilities for a target. */
+export async function getTargetSafetyLiabilities(ensemblId) {
+    const data = await gqlFetch(SAFETY_QUERY, { ensemblId }, TargetSafetyDataSchema);
+    const target = data.target;
+    if (!target)
+        return null;
+    const safetyLiabilities = (target.safetyLiabilities ?? []).map((sl) => ({
+        event: sl.event ?? "Unknown",
+        biosamples: Array.isArray(sl.biosamples) ? sl.biosamples.map((b) => b.tissueLabel ?? "").filter(Boolean) : [],
+        effects: Array.isArray(sl.effects) && sl.effects.length > 0
+            ? sl.effects
+                .map((e) => e.direction ?? "")
+                .filter(Boolean)
+                .join(", ")
+            : null,
+        source: sl.datasource ?? "Unknown",
+    }));
+    return { targetSymbol: target.approvedSymbol, safetyLiabilities };
+}
+/**
+ * Fetch baseline RNA/protein expression across tissues. Open Targets
+ * exposes per-tissue expression with organ system tags — used by §2.7
+ * (Off-Tissue Risk) and §3.9 (Normal Tissue Expression).
+ */
+export async function getBaselineExpression(ensemblId) {
+    const data = await gqlFetch(EXPRESSION_QUERY, { ensemblId }, TargetExpressionDataSchema);
+    const expressions = data.target?.expressions ?? [];
+    return expressions.map((e) => ({
+        tissueId: e.tissue.id,
+        tissueLabel: e.tissue.label,
+        organSystem: Array.isArray(e.tissue.organs) && e.tissue.organs.length > 0 ? e.tissue.organs[0] : null,
+        rna: e.rna && typeof e.rna.value === "number" ? { value: e.rna.value, unit: e.rna.unit ?? "TPM" } : null,
+        protein: e.protein ? { level: typeof e.protein.level === "number" ? e.protein.level : null } : null,
+    }));
+}

package/dist/tools/lib/opentargets-config.d.ts

@@ -0,0 +1,5 @@
+export declare const OT_GRAPHQL = "https://api.platform.opentargets.org/api/v4/graphql";
+export declare const OT_HEADERS: {
+    readonly "Content-Type": "application/json";
+    readonly Accept: "application/json";
+};

package/dist/tools/lib/opentargets-config.js

@@ -0,0 +1,5 @@
+export const OT_GRAPHQL = "https://api.platform.opentargets.org/api/v4/graphql";
+export const OT_HEADERS = {
+    "Content-Type": "application/json",
+    Accept: "application/json",
+};

package/dist/tools/lib/path-validation.d.ts

@@ -0,0 +1,14 @@
+/**
+ * Shared path-shape validation for display-card references.
+ *
+ * `show_file` and `show_user`'s echart `dataPath` both name analysis-rooted
+ * artifact paths the host resolves to viewable content at render time. The
+ * shape rules are identical and live here as the single source: non-empty,
+ * length-capped, no NUL, no leading slash (must be analysis-rooted, not
+ * absolute), no `..` traversal segment. Neither tool checks that the file
+ * exists — a reference that fails to resolve degrades at render time.
+ */
+/** Max length of an analysis-rooted reference path. */
+export declare const MAX_PATH_LEN = 1024;
+/** Returns null for a legal analysis-rooted path, an error code otherwise. */
+export declare function validatePath(path: string): null | "invalid_path";

package/dist/tools/lib/path-validation.js

@@ -0,0 +1,26 @@
+/**
+ * Shared path-shape validation for display-card references.
+ *
+ * `show_file` and `show_user`'s echart `dataPath` both name analysis-rooted
+ * artifact paths the host resolves to viewable content at render time. The
+ * shape rules are identical and live here as the single source: non-empty,
+ * length-capped, no NUL, no leading slash (must be analysis-rooted, not
+ * absolute), no `..` traversal segment. Neither tool checks that the file
+ * exists — a reference that fails to resolve degrades at render time.
+ */
+/** Max length of an analysis-rooted reference path. */
+export const MAX_PATH_LEN = 1024;
+/** Returns null for a legal analysis-rooted path, an error code otherwise. */
+export function validatePath(path) {
+    if (path.length === 0 || path.length > MAX_PATH_LEN)
+        return "invalid_path";
+    if (path.includes("\0"))
+        return "invalid_path";
+    if (path.startsWith("/"))
+        return "invalid_path";
+    for (const segment of path.split("/")) {
+        if (segment === "..")
+            return "invalid_path";
+    }
+    return null;
+}

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

@@ -0,0 +1,27 @@
+/**
+ * Pure async client functions for biological pathway lookups via KEGG and Reactome.
+ *
+ * Used by §3.7 (Pathway Context).
+ */
+export declare function stripHtmlAndCollapseWs(s: string): string;
+export type PathwaySource = "kegg" | "reactome";
+export interface Pathway {
+    id: string;
+    name: string;
+    source: PathwaySource;
+    description?: string;
+    genes?: string[];
+    entity_uniprots?: string[];
+    url?: string;
+}
+export interface PathwaySearchOptions {
+    source?: "kegg" | "reactome" | "both";
+    organism?: string;
+    includeGenes?: boolean;
+    maxResults?: number;
+}
+export declare function searchKegg(query: string, organism: string, maxResults: number, includeGenes: boolean): Promise<Pathway[]>;
+export declare function searchReactome(query: string, species: string, maxResults: number, includeGenes: boolean): Promise<Pathway[]>;
+export declare function searchPathways(query: string, options?: PathwaySearchOptions): Promise<Pathway[]>;
+/** Pathway memberships for a gene symbol — used directly by §3.7 collector. */
+export declare function getPathwayMemberships(geneSymbol: string): Promise<Pathway[]>;