@inflexa-ai/harness 0.45.0 → 0.46.0

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

@@ -7,7 +7,34 @@
  * `z.discriminatedUnion`, which `defineTool` rejects (model tool calling needs a
  * top-level `"type":"object"`).
  */
+import { z } from "zod";
+import { type Tool } from "../define-tool.js";
 import { type PatentRecord, type PatentSummary } from "../lib/amass-client.js";
+declare const inputSchema: z.ZodObject<{
+    action: z.ZodDefault<z.ZodEnum<{
+        details: "details";
+        search: "search";
+    }>>;
+    query: z.ZodOptional<z.ZodString>;
+    assignee: z.ZodOptional<z.ZodArray<z.ZodString>>;
+    inventor: z.ZodOptional<z.ZodString>;
+    cpcCodes: z.ZodOptional<z.ZodArray<z.ZodString>>;
+    countryCode: z.ZodOptional<z.ZodArray<z.ZodString>>;
+    minPublicationDate: z.ZodOptional<z.ZodString>;
+    maxPublicationDate: z.ZodOptional<z.ZodString>;
+    minFilingDate: z.ZodOptional<z.ZodString>;
+    maxFilingDate: z.ZodOptional<z.ZodString>;
+    minPriorityDate: z.ZodOptional<z.ZodString>;
+    maxPriorityDate: z.ZodOptional<z.ZodString>;
+    minGrantDate: z.ZodOptional<z.ZodString>;
+    maxGrantDate: z.ZodOptional<z.ZodString>;
+    limit: z.ZodDefault<z.ZodNumber>;
+    amassId: z.ZodOptional<z.ZodString>;
+    publicationNumber: z.ZodOptional<z.ZodString>;
+    applicationNumber: z.ZodOptional<z.ZodString>;
+    includeClaims: z.ZodDefault<z.ZodBoolean>;
+    includeDescription: z.ZodDefault<z.ZodBoolean>;
+}, z.core.$strip>;
 type PatentsOutput = {
     patents: PatentSummary[];
 } | {
@@ -21,26 +48,5 @@ type PatentsOutput = {
 };
 export declare function createSearchPatentsTool(deps: {
     apiKey: string;
-}): import("../define-tool.js").Tool<{
-    action: "search" | "details";
-    limit: number;
-    includeClaims: boolean;
-    includeDescription: boolean;
-    query?: string | undefined;
-    assignee?: string[] | undefined;
-    inventor?: string | undefined;
-    cpcCodes?: string[] | undefined;
-    countryCode?: string[] | undefined;
-    minPublicationDate?: string | undefined;
-    maxPublicationDate?: string | undefined;
-    minFilingDate?: string | undefined;
-    maxFilingDate?: string | undefined;
-    minPriorityDate?: string | undefined;
-    maxPriorityDate?: string | undefined;
-    minGrantDate?: string | undefined;
-    maxGrantDate?: string | undefined;
-    amassId?: string | undefined;
-    publicationNumber?: string | undefined;
-    applicationNumber?: string | undefined;
-}, PatentsOutput>;
+}): Tool<z.infer<typeof inputSchema>, PatentsOutput>;
 export {};

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

@@ -8,16 +8,17 @@
  * top-level `"type":"object"`).
  */
 import { err, ok } from "neverthrow";
+import { presentFirst } from "../../lib/present.js";
 import { z } from "zod";
 import { defineTool } from "../define-tool.js";
 import { describeAmassError, getPatentRecord, lookupPatentIds, searchPatentRecords, } from "../lib/amass-client.js";
 import { getAmassHeaders } from "../lib/amass-config.js";
+import { ISO_DATE_PATTERN } from "../../lib/text.js";
 /** The largest `limit` that still costs one search price (5 credits for each 20 records). */
 const MAX_LIMIT = 20;
-const ISO_DATE = /^\d{4}-\d{2}-\d{2}$/;
 const IDENTIFIER_FIELDS = ["amassId", "publicationNumber", "applicationNumber"];
 function dateField(description) {
-    return z.string().regex(ISO_DATE).optional().describe(`'search' only. ${description}, YYYY-MM-DD.`);
+    return z.string().regex(ISO_DATE_PATTERN).optional().describe(`'search' only. ${description}, YYYY-MM-DD.`);
 }
 const inputSchema = z
     .object({
@@ -91,21 +92,23 @@ export function createSearchPatentsTool(deps) {
         execute: async (input) => {
             const headers = getAmassHeaders(deps.apiKey);
             if (input.action === "search") {
+                if (input.query === undefined)
+                    throw new Error("search requires query");
                 const patents = await searchPatentRecords({
                     query: input.query,
                     limit: input.limit,
-                    ...(input.assignee ? { assignee: input.assignee } : {}),
-                    ...(input.inventor ? { inventor: input.inventor } : {}),
-                    ...(input.cpcCodes ? { cpcCodes: input.cpcCodes } : {}),
-                    ...(input.countryCode ? { countryCode: input.countryCode } : {}),
-                    ...(input.minPublicationDate ? { minPublicationDate: input.minPublicationDate } : {}),
-                    ...(input.maxPublicationDate ? { maxPublicationDate: input.maxPublicationDate } : {}),
-                    ...(input.minFilingDate ? { minFilingDate: input.minFilingDate } : {}),
-                    ...(input.maxFilingDate ? { maxFilingDate: input.maxFilingDate } : {}),
-                    ...(input.minPriorityDate ? { minPriorityDate: input.minPriorityDate } : {}),
-                    ...(input.maxPriorityDate ? { maxPriorityDate: input.maxPriorityDate } : {}),
-                    ...(input.minGrantDate ? { minGrantDate: input.minGrantDate } : {}),
-                    ...(input.maxGrantDate ? { maxGrantDate: input.maxGrantDate } : {}),
+                    assignee: input.assignee ? input.assignee : undefined,
+                    inventor: input.inventor ? input.inventor : undefined,
+                    cpcCodes: input.cpcCodes ? input.cpcCodes : undefined,
+                    countryCode: input.countryCode ? input.countryCode : undefined,
+                    minPublicationDate: input.minPublicationDate,
+                    maxPublicationDate: input.maxPublicationDate,
+                    minFilingDate: input.minFilingDate,
+                    maxFilingDate: input.maxFilingDate,
+                    minPriorityDate: input.minPriorityDate,
+                    maxPriorityDate: input.maxPriorityDate,
+                    minGrantDate: input.minGrantDate,
+                    maxGrantDate: input.maxGrantDate,
                 }, headers);
                 if (patents.isErr())
                     return failure(patents.error);
@@ -114,8 +117,8 @@ export function createSearchPatentsTool(deps) {
             let amassId = input.amassId;
             if (amassId === undefined) {
                 const ids = await lookupPatentIds({
-                    ...(input.publicationNumber === undefined ? {} : { publicationNumber: input.publicationNumber }),
-                    ...(input.applicationNumber === undefined ? {} : { applicationNumber: input.applicationNumber }),
+                    publicationNumber: input.publicationNumber,
+                    applicationNumber: input.applicationNumber,
                 }, headers);
                 if (ids.isErr())
                     return failure(ids.error);
@@ -123,7 +126,7 @@ export function createSearchPatentsTool(deps) {
                     return ok({ status: "not_found" });
                 if (ids.value.length > 1)
                     return ok({ status: "ambiguous", candidates: ids.value });
-                amassId = ids.value[0];
+                amassId = presentFirst(ids.value, "the single patent id");
             }
             const patent = await getPatentRecord(amassId, { claims: input.includeClaims, description: input.includeDescription }, headers);
             if (patent.isErr())

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

@@ -7,11 +7,11 @@
  * and its accession is the key that the structural tools take.
  */
 import { type UniProtProtein } from "../lib/uniprot-client.js";
-export interface SearchProteinOutput {
+export type SearchProteinOutput = {
     readonly proteins: UniProtProtein[];
     /** True when UniProt held at least one row beyond `limit`. */
     readonly hasMore: boolean;
-}
+};
 export declare const searchProteinTool: import("../define-tool.js").Tool<{
     query: string;
     organismId: number | null;

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

@@ -52,7 +52,7 @@ export const searchProteinTool = defineTool({
     describeCall: ({ query }) => query,
     execute: async ({ query, organismId, reviewedOnly, limit }) => {
         const result = await searchProteins(query, {
-            ...(organismId === null ? {} : { organismId }),
+            organismId: organismId ?? undefined,
             reviewedOnly,
             limit,
         });

package/dist/tools/bio/search-regulatory-approvals.d.ts

@@ -11,7 +11,70 @@
  * `z.discriminatedUnion`, which `defineTool` rejects (model tool calling needs a
  * top-level `"type":"object"`).
  */
+import { z } from "zod";
+import { type Tool } from "../define-tool.js";
 import { type AuthorizationRecord, type AuthorizationSearchRow, type RegulatorySection } from "../lib/amass-client.js";
+declare const inputSchema: z.ZodObject<{
+    action: z.ZodDefault<z.ZodEnum<{
+        details: "details";
+        search: "search";
+        section: "section";
+    }>>;
+    query: z.ZodOptional<z.ZodString>;
+    agency: z.ZodOptional<z.ZodArray<z.ZodEnum<{
+        EMA: "EMA";
+        FDA: "FDA";
+    }>>>;
+    authorizationStatus: z.ZodOptional<z.ZodArray<z.ZodEnum<{
+        ACTIVE: "ACTIVE";
+        APPROVED_NOT_MARKETED: "APPROVED_NOT_MARKETED";
+        CONDITIONAL: "CONDITIONAL";
+        EXPIRED: "EXPIRED";
+        LAPSED_SUNSET: "LAPSED_SUNSET";
+        REFUSED: "REFUSED";
+        REVOKED: "REVOKED";
+        SUSPENDED: "SUSPENDED";
+        UNKNOWN: "UNKNOWN";
+        WITHDRAWN_DURING_REVIEW: "WITHDRAWN_DURING_REVIEW";
+        WITHDRAWN_FORCED: "WITHDRAWN_FORCED";
+        WITHDRAWN_VOLUNTARY: "WITHDRAWN_VOLUNTARY";
+    }>>>;
+    moleculeType: z.ZodOptional<z.ZodArray<z.ZodEnum<{
+        ANTIBODY: "ANTIBODY";
+        ANTIBODY_DRUG_CONJUGATE: "ANTIBODY_DRUG_CONJUGATE";
+        CELL: "CELL";
+        ENZYME: "ENZYME";
+        GENE: "GENE";
+        OLIGONUCLEOTIDE: "OLIGONUCLEOTIDE";
+        OLIGOSACCHARIDE: "OLIGOSACCHARIDE";
+        PROTEIN: "PROTEIN";
+        SMALL_MOLECULE: "SMALL_MOLECULE";
+        UNKNOWN: "UNKNOWN";
+        VACCINE: "VACCINE";
+        VACCINE_COMPONENT: "VACCINE_COMPONENT";
+    }>>>;
+    hasDesignation: z.ZodOptional<z.ZodArray<z.ZodEnum<{
+        ACCELERATED_APPROVAL: "ACCELERATED_APPROVAL";
+        ACCELERATED_ASSESSMENT: "ACCELERATED_ASSESSMENT";
+        BREAKTHROUGH_THERAPY: "BREAKTHROUGH_THERAPY";
+        CONDITIONAL_MA: "CONDITIONAL_MA";
+        EXCEPTIONAL_CIRCUMSTANCES: "EXCEPTIONAL_CIRCUMSTANCES";
+        FAST_TRACK: "FAST_TRACK";
+        PRIME: "PRIME";
+        PRIORITY_REVIEW: "PRIORITY_REVIEW";
+        RMAT: "RMAT";
+    }>>>;
+    isOrphan: z.ZodOptional<z.ZodBoolean>;
+    minAuthorizationDate: z.ZodOptional<z.ZodString>;
+    maxAuthorizationDate: z.ZodOptional<z.ZodString>;
+    limit: z.ZodDefault<z.ZodNumber>;
+    amassId: z.ZodOptional<z.ZodString>;
+    fdaApplicationNumber: z.ZodOptional<z.ZodString>;
+    emaProductNumber: z.ZodOptional<z.ZodString>;
+    ndc: z.ZodOptional<z.ZodString>;
+    splSetId: z.ZodOptional<z.ZodString>;
+    documentSectionId: z.ZodOptional<z.ZodString>;
+}, z.core.$strip>;
 type RegulatoryApprovalsOutput = {
     authorizations: AuthorizationSearchRow[];
 } | {
@@ -28,22 +91,5 @@ type RegulatoryApprovalsOutput = {
 };
 export declare function createSearchRegulatoryApprovalsTool(deps: {
     apiKey: string;
-}): import("../define-tool.js").Tool<{
-    action: "search" | "details" | "section";
-    limit: number;
-    query?: string | undefined;
-    agency?: ("FDA" | "EMA")[] | undefined;
-    authorizationStatus?: ("UNKNOWN" | "ACTIVE" | "APPROVED_NOT_MARKETED" | "CONDITIONAL" | "SUSPENDED" | "WITHDRAWN_VOLUNTARY" | "WITHDRAWN_FORCED" | "REVOKED" | "LAPSED_SUNSET" | "REFUSED" | "WITHDRAWN_DURING_REVIEW" | "EXPIRED")[] | undefined;
-    moleculeType?: ("UNKNOWN" | "SMALL_MOLECULE" | "ANTIBODY" | "PROTEIN" | "ENZYME" | "OLIGONUCLEOTIDE" | "GENE" | "CELL" | "ANTIBODY_DRUG_CONJUGATE" | "VACCINE_COMPONENT" | "VACCINE" | "OLIGOSACCHARIDE")[] | undefined;
-    hasDesignation?: ("PRIORITY_REVIEW" | "BREAKTHROUGH_THERAPY" | "FAST_TRACK" | "RMAT" | "ACCELERATED_APPROVAL" | "ACCELERATED_ASSESSMENT" | "PRIME" | "CONDITIONAL_MA" | "EXCEPTIONAL_CIRCUMSTANCES")[] | undefined;
-    isOrphan?: boolean | undefined;
-    minAuthorizationDate?: string | undefined;
-    maxAuthorizationDate?: string | undefined;
-    amassId?: string | undefined;
-    fdaApplicationNumber?: string | undefined;
-    emaProductNumber?: string | undefined;
-    ndc?: string | undefined;
-    splSetId?: string | undefined;
-    documentSectionId?: string | undefined;
-}, RegulatoryApprovalsOutput>;
+}): Tool<z.infer<typeof inputSchema>, RegulatoryApprovalsOutput>;
 export {};

package/dist/tools/bio/search-regulatory-approvals.js

@@ -12,13 +12,14 @@
  * top-level `"type":"object"`).
  */
 import { err, ok } from "neverthrow";
+import { presentFirst } from "../../lib/present.js";
 import { z } from "zod";
 import { defineTool } from "../define-tool.js";
 import { describeAmassError, getRegulatoryRecord, getRegulatorySection, lookupRegulatoryIds, MAX_MATCHED_SECTIONS, REGULATORY_AGENCIES, REGULATORY_AUTHORIZATION_STATUSES, REGULATORY_DESIGNATIONS, REGULATORY_MOLECULE_TYPES, searchRegulatoryRecords, } from "../lib/amass-client.js";
 import { getAmassHeaders } from "../lib/amass-config.js";
+import { ISO_DATE_PATTERN } from "../../lib/text.js";
 /** The largest `limit` that still costs one search price (5 credits for each 20 records). */
 const MAX_LIMIT = 20;
-const ISO_DATE = /^\d{4}-\d{2}-\d{2}$/;
 const IDENTIFIER_FIELDS = ["amassId", "fdaApplicationNumber", "emaProductNumber", "ndc", "splSetId"];
 const inputSchema = z
     .object({
@@ -43,8 +44,8 @@ const inputSchema = z
         .optional()
         .describe("'search' only. Keep the authorizations that carry any of these designations."),
     isOrphan: z.boolean().optional().describe("'search' only. true keeps the FDA Orphan Drug / EMA Orphan Medicine authorizations; false drops them."),
-    minAuthorizationDate: z.string().regex(ISO_DATE).optional().describe("'search' only. Earliest authorization date, YYYY-MM-DD."),
-    maxAuthorizationDate: z.string().regex(ISO_DATE).optional().describe("'search' only. Latest authorization date, YYYY-MM-DD."),
+    minAuthorizationDate: z.string().regex(ISO_DATE_PATTERN).optional().describe("'search' only. Earliest authorization date, YYYY-MM-DD."),
+    maxAuthorizationDate: z.string().regex(ISO_DATE_PATTERN).optional().describe("'search' only. Latest authorization date, YYYY-MM-DD."),
     limit: z
         .number()
         .int()
@@ -111,23 +112,27 @@ export function createSearchRegulatoryApprovalsTool(deps) {
         execute: async (input) => {
             const headers = getAmassHeaders(deps.apiKey);
             if (input.action === "search") {
+                if (input.query === undefined)
+                    throw new Error("search requires query");
                 const rows = await searchRegulatoryRecords({
                     query: input.query,
                     limit: input.limit,
-                    ...(input.agency ? { agency: input.agency } : {}),
-                    ...(input.authorizationStatus ? { authorizationStatus: input.authorizationStatus } : {}),
-                    ...(input.moleculeType ? { moleculeType: input.moleculeType } : {}),
-                    ...(input.hasDesignation ? { hasDesignation: input.hasDesignation } : {}),
-                    ...(input.isOrphan === undefined ? {} : { isOrphan: input.isOrphan }),
-                    ...(input.minAuthorizationDate ? { minAuthorizationDate: input.minAuthorizationDate } : {}),
-                    ...(input.maxAuthorizationDate ? { maxAuthorizationDate: input.maxAuthorizationDate } : {}),
-                    ...(input.amassId ? { amassId: input.amassId } : {}),
+                    agency: input.agency ? input.agency : undefined,
+                    authorizationStatus: input.authorizationStatus ? input.authorizationStatus : undefined,
+                    moleculeType: input.moleculeType ? input.moleculeType : undefined,
+                    hasDesignation: input.hasDesignation ? input.hasDesignation : undefined,
+                    isOrphan: input.isOrphan,
+                    minAuthorizationDate: input.minAuthorizationDate,
+                    maxAuthorizationDate: input.maxAuthorizationDate,
+                    amassId: input.amassId ? input.amassId : undefined,
                 }, headers);
                 if (rows.isErr())
                     return failure(rows.error);
                 return ok({ authorizations: rows.value });
             }
             if (input.action === "section") {
+                if (input.amassId === undefined || input.documentSectionId === undefined)
+                    throw new Error("section requires amassId and documentSectionId");
                 const section = await getRegulatorySection(input.amassId, input.documentSectionId, headers);
                 if (section.isErr())
                     return failure(section.error);
@@ -136,10 +141,10 @@ export function createSearchRegulatoryApprovalsTool(deps) {
             let amassId = input.amassId;
             if (amassId === undefined) {
                 const ids = await lookupRegulatoryIds({
-                    ...(input.fdaApplicationNumber === undefined ? {} : { fdaApplicationNumber: input.fdaApplicationNumber }),
-                    ...(input.emaProductNumber === undefined ? {} : { emaProductNumber: input.emaProductNumber }),
-                    ...(input.ndc === undefined ? {} : { ndc: input.ndc }),
-                    ...(input.splSetId === undefined ? {} : { splSetId: input.splSetId }),
+                    fdaApplicationNumber: input.fdaApplicationNumber,
+                    emaProductNumber: input.emaProductNumber,
+                    ndc: input.ndc,
+                    splSetId: input.splSetId,
                 }, headers);
                 if (ids.isErr())
                     return failure(ids.error);
@@ -147,7 +152,7 @@ export function createSearchRegulatoryApprovalsTool(deps) {
                     return ok({ status: "not_found" });
                 if (ids.value.length > 1)
                     return ok({ status: "ambiguous", candidates: ids.value });
-                amassId = ids.value[0];
+                amassId = presentFirst(ids.value, "the single regulatory id");
             }
             const record = await getRegulatoryRecord(amassId, headers);
             if (record.isErr())

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

@@ -16,7 +16,7 @@ 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 {
+type TargetRow = {
     input: string;
     identifierType: ConcreteType;
     /** The Ensembl id Open Targets was queried with, when one could be obtained. */
@@ -27,27 +27,27 @@ interface TargetRow {
     liabilityCount?: number;
     /** Why the Open Targets half is absent for this identifier, when it is. */
     opentargetsNote?: string;
-}
-interface SourceOutcome {
+};
+type 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;
+    identifierType?: "auto" | "chembl_id" | "ensembl_id" | "gene_symbol" | "uniprot" | undefined;
     sources?: ("opentargets" | "panel")[] | undefined;
-    filterOrgan?: "hematologic" | "metabolic" | "immune" | "hepatic" | "musculoskeletal" | "cns" | "renal" | "reproductive" | "respiratory" | "cardiac" | "vascular" | "pns" | "gi" | "pancreas" | "endocrine_thyroid" | "dermatologic" | "ocular" | "oncology" | undefined;
-    minSeverity?: "low" | "medium" | "high" | undefined;
+    filterOrgan?: "cardiac" | "cns" | "dermatologic" | "endocrine_thyroid" | "gi" | "hematologic" | "hepatic" | "immune" | "metabolic" | "musculoskeletal" | "ocular" | "oncology" | "pancreas" | "pns" | "renal" | "reproductive" | "respiratory" | "vascular" | undefined;
+    minSeverity?: "high" | "low" | "medium" | undefined;
     liabilityLimit?: number | undefined;
 }, {
     perSource: SourceOutcome[];
     summary: {
         totalInput: number;
         panelMatched: number;
-        bySeverity: Record<"low" | "medium" | "high", number>;
+        bySeverity: Record<"high" | "low" | "medium", number>;
         byOrgan: Record<string, number>;
         openTargetsWithLiabilities: number;
     };

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

@@ -11,6 +11,8 @@
  * 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 { errorMessageOf } from "../../lib/thrown.js";
+import { textOf } from "../../lib/unknown-text.js";
 import { ok } from "neverthrow";
 import { z } from "zod";
 import { ORGAN_SYSTEMS } from "../../contracts/organ-system.js";
@@ -19,12 +21,15 @@ import { CHEMBL_RE, SafetyPanelFileSchema, UNIPROT_RE } from "../../data/safety-
 import panelData from "../../data/safety-panel.json" with { type: "json" };
 import { defineTool } from "../define-tool.js";
 import { resolveSymbolToEnsemblId } from "../lib/ensembl-client.js";
+import { isAllDigits } from "../../lib/text.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}$/;
+function isEnsemblGeneId(id) {
+    return id.startsWith("ENSG") && id.length === 15 && isAllDigits(id.slice(4));
+}
 /** Ordered weakest → strongest so `minSeverity` can be a numeric floor. */
 const SEVERITY_ORDER = { low: 0, medium: 1, high: 2 };
 const SOURCES = ["panel", "opentargets"];
@@ -35,7 +40,7 @@ const DEFAULT_LIABILITY_LIMIT = 10;
 function detectType(id) {
     if (CHEMBL_RE.test(id))
         return "chembl_id";
-    if (ENSG_RE.test(id))
+    if (isEnsemblGeneId(id))
         return "ensembl_id";
     if (UNIPROT_RE.test(id))
         return "uniprot";
@@ -84,7 +89,7 @@ const inputSchema = z
         .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, {
+    .refine((d) => !(d.sources ?? [...SOURCES]).includes("opentargets") || 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"],
@@ -150,7 +155,7 @@ export const targetSafetyTool = defineTool({
                     row.liabilities = result.safetyLiabilities.slice(0, limit);
                 }
                 catch (error) {
-                    opentargetsError = error instanceof Error ? error.message : String(error);
+                    opentargetsError = errorMessageOf(error) ?? textOf(error);
                     row.opentargetsNote = "Open Targets could not be reached";
                 }
             }));
@@ -175,7 +180,7 @@ export const targetSafetyTool = defineTool({
                 source: "opentargets",
                 status: opentargetsError ? "unavailable" : withLiabilities > 0 ? "ok" : "no_data",
                 matched: withLiabilities,
-                ...(opentargetsError ? { detail: opentargetsError } : {}),
+                detail: opentargetsError,
             });
         }
         return ok({
@@ -184,7 +189,7 @@ export const targetSafetyTool = defineTool({
                 totalInput: identifiers.length,
                 panelMatched,
                 bySeverity,
-                byOrgan: byOrgan,
+                byOrgan,
                 openTargetsWithLiabilities: withLiabilities,
             },
             targets: rows,

package/dist/tools/capability-data.d.ts

@@ -0,0 +1,40 @@
+/**
+ * inspectCapabilityData — the reference data a specialist capability cannot run without, and
+ * whether this store holds it.
+ *
+ * The method of a capability lives in a skill pack, and only a sandbox step agent reads a skill.
+ * Thus a conversation or planning surface knows a capability by its phrase alone, and it cannot
+ * name the datasets the method needs. It then does one of two wrong things: it calls the work
+ * impossible, or it designs a method around what it can see and substitutes for what it cannot.
+ *
+ * The declaration on the agent metadata is the one place a surface above the step can read, and
+ * this tool is how it reads it. The answer names an absent dataset by its CATALOG ID, because the
+ * id is what an install takes — a surface that can provision needs the identifier, not a
+ * description. Where the ids reach an agent matters: a prompt names no dataset, so the knowledge
+ * arrives through a tool, which carries its own description into the context at attach time.
+ */
+import { z } from "zod";
+import type { EnvironmentStorePaths } from "../config/environment-stores.js";
+import { type Tool } from "./define-tool.js";
+export type InspectCapabilityDataDeps = Pick<EnvironmentStorePaths, "refStorePath">;
+/** One capability, its declared datasets, and what the store holds of them. */
+export type CapabilityDataRow = {
+    readonly agentId: string;
+    readonly capability: string;
+    readonly installed: readonly string[];
+    readonly absent: readonly string[];
+};
+export type CapabilityDataResult = {
+    /** False when the store could not be answered for: every `absent` list is then unknown, not empty. */
+    readonly storeReadable: boolean;
+    readonly rows: readonly CapabilityDataRow[];
+    readonly content: string;
+};
+/**
+ * Build the tool. The store read happens per call, not at construction: a dataset installed during
+ * the conversation must show as installed on the next call, and a cached answer would have the
+ * agent offer a download the user already approved.
+ */
+declare const CapabilityDataInputSchema: z.ZodObject<{}, z.core.$strip>;
+export declare function createInspectCapabilityDataTool(deps?: InspectCapabilityDataDeps): Tool<z.infer<typeof CapabilityDataInputSchema>, CapabilityDataResult>;
+export {};

package/dist/tools/capability-data.js

@@ -0,0 +1,74 @@
+/**
+ * inspectCapabilityData — the reference data a specialist capability cannot run without, and
+ * whether this store holds it.
+ *
+ * The method of a capability lives in a skill pack, and only a sandbox step agent reads a skill.
+ * Thus a conversation or planning surface knows a capability by its phrase alone, and it cannot
+ * name the datasets the method needs. It then does one of two wrong things: it calls the work
+ * impossible, or it designs a method around what it can see and substitutes for what it cannot.
+ *
+ * The declaration on the agent metadata is the one place a surface above the step can read, and
+ * this tool is how it reads it. The answer names an absent dataset by its CATALOG ID, because the
+ * id is what an install takes — a surface that can provision needs the identifier, not a
+ * description. Where the ids reach an agent matters: a prompt names no dataset, so the knowledge
+ * arrives through a tool, which carries its own description into the context at attach time.
+ */
+import { ok } from "neverthrow";
+import { z } from "zod";
+import { declaredDataRequirements } from "../agents/sandbox-catalog.js";
+import { defineTool } from "./define-tool.js";
+import { readInstalledDatasetIds } from "./sandbox/list-available-refs.js";
+const NO_DECLARATIONS = "No capability of this install declares reference data that it cannot run without.";
+const STORE_UNREADABLE = "The reference store could not be read, so whether these datasets are installed is UNKNOWN — not absent. " +
+    "Say that, and do not offer to install a dataset on this answer alone.";
+function renderRows(rows, storeReadable) {
+    if (rows.length === 0)
+        return NO_DECLARATIONS;
+    const lines = rows.map((row) => {
+        const state = storeReadable
+            ? [row.absent.length > 0 ? `absent: ${row.absent.join(", ")}` : null, row.installed.length > 0 ? `installed: ${row.installed.join(", ")}` : null]
+                .filter((part) => part !== null)
+                .join(" | ")
+            : `declared: ${[...row.installed, ...row.absent].sort().join(", ")}`;
+        return `- ${row.agentId} — "${row.capability}"\n  ${state}`;
+    });
+    const header = storeReadable
+        ? "Reference data a capability cannot run without, and what this store holds. An absent id is what an install takes."
+        : `Reference data a capability cannot run without. ${STORE_UNREADABLE}`;
+    return [header, "", ...lines].join("\n");
+}
+/**
+ * Build the tool. The store read happens per call, not at construction: a dataset installed during
+ * the conversation must show as installed on the next call, and a cached answer would have the
+ * agent offer a download the user already approved.
+ */
+const CapabilityDataInputSchema = z.object({});
+export function createInspectCapabilityDataTool(deps = {}) {
+    return defineTool({
+        id: "inspect_capability_data",
+        description: "The reference data a specialist capability cannot run without, and whether this install holds it. " +
+            "Call it BEFORE you design a method yourself, and before you tell the user that something cannot be done — a capability whose data is absent is one install away, not impossible, and this is the only place that names WHICH datasets. " +
+            "Each entry names a catalog dataset id, which is exactly what an install takes; a surface with a way to provision can act on it directly. " +
+            "It takes no arguments and the whole set is small, so one call is the complete answer. " +
+            "An unreadable store answers UNKNOWN rather than absent, so a store that cannot be read never reads as a store that holds nothing.",
+        inputSchema: CapabilityDataInputSchema,
+        describeCall: () => "declared capability data",
+        execute: async () => {
+            const declared = declaredDataRequirements();
+            if (declared.length === 0)
+                return ok({ storeReadable: true, rows: [], content: NO_DECLARATIONS });
+            const installedIds = await readInstalledDatasetIds(deps);
+            const storeReadable = installedIds !== undefined;
+            const rows = declared.map((requirement) => {
+                const datasets = [...requirement.datasets].sort();
+                return {
+                    agentId: requirement.agentId,
+                    capability: requirement.capability,
+                    installed: installedIds === undefined ? [] : datasets.filter((dataset) => installedIds.has(dataset)),
+                    absent: installedIds === undefined ? datasets : datasets.filter((dataset) => !installedIds.has(dataset)),
+                };
+            });
+            return ok({ storeReadable, rows, content: renderRows(rows, storeReadable) });
+        },
+    });
+}