@inflexa-ai/harness 0.45.1 → 0.46.0

package/dist/tools/approval/gateway.js

@@ -1,82 +1,44 @@
 /**
- * The poll-based tool-approval gateway — the constructed `Ask` seam realization
- * an embedder wires over its Postgres pool, plus the outward `answer` / `pending`
- * API it drives and the boot-time `sweepExpired`.
- *
- * `ask` is the per-turn seam an embedder binds: a conversation tool's `ctx.ask`
- * pauses on it. The database is the single source of truth for ask state — `ask`
- * inserts a `pending` ledger row, emits the `data-ask` part, and polls that row to
- * a terminal status; there is no in-memory resolver map. `answer` is one guarded
- * write. See the poll site below for why.
+ * The tool-approval gateway: the ask ledger over the Postgres pool of an
+ * embedder. A turn workflow raises an ask under a known id and waits for the
+ * answer itself. `answer` is one guarded write, and `pending` and the boot-time
+ * `sweepExpired` read and expire the ledger.
  */
 import { unwrapOrThrow } from "../../lib/result.js";
-import { AskRejectedError } from "./contract.js";
-import { answerAsk, insertGrantedAsk, insertPendingAsk, markAborted, selectAskResolution, selectGrant, selectPending, sweepExpired as sweepExpiredRows, } from "./queries.js";
-import { uuidv7 } from "./uuidv7.js";
-/** Fixed poll cadence — imperceptible against human decision speed, low chatter. */
-const POLL_INTERVAL_MS = 200;
+import { answerAsk, insertGrantedAsk, insertPendingAsk, markAborted, markExpired, selectGrant, selectPending, sweepExpired as sweepExpiredRows, } from "./queries.js";
 /**
  * Pending rows older than this are treated as orphans of a dead process. Far
  * beyond any plausible live turn, so a boot sweep during a rolling deployment
- * cannot expire an ask another pod is still polling.
+ * cannot expire an ask another pod is still waiting on.
  */
 export const DEFAULT_SWEEP_MAX_AGE_MS = 24 * 60 * 60 * 1000;
 export function createAskGateway(deps) {
     const { pool } = deps;
-    async function ask(request, ctx) {
-        const id = uuidv7();
+    async function raise(id, request, scope) {
         const now = new Date().toISOString();
         const row = {
             id,
-            analysisId: ctx.analysisId,
-            userId: ctx.userId,
-            threadId: ctx.threadId ?? null,
+            analysisId: scope.analysisId,
+            userId: scope.userId,
+            threadId: scope.threadId ?? null,
             title: request.title,
             command: request.command,
             detail: request.detail ?? null,
             grantKey: request.grantKey ?? null,
             createdAt: now,
         };
-        // A standing grant this user holds for this ask's grant key — the command
-        // unless the tool supplied a broader key — short-circuits the prompt: record
-        // the invocation as `resolved` for the audit trail and return without pausing.
-        // The one part it emits is already settled, so no surface prompts, and the
-        // transcript still shows that a standing grant approved the call.
-        if (unwrapOrThrow(await selectGrant(pool, ctx.analysisId, ctx.userId, request.grantKey ?? request.command))) {
+        if (unwrapOrThrow(await selectGrant(pool, scope.analysisId, scope.userId, request.grantKey ?? request.command))) {
             unwrapOrThrow(await insertGrantedAsk(pool, row, now));
-            await emitAskPart(ctx.emit, id, request, "resolved", "always");
-            return { kind: "always" };
+            return "granted";
         }
         unwrapOrThrow(await insertPendingAsk(pool, row));
-        await emitAskPart(ctx.emit, id, request, "pending");
-        // DESIGN(WHY): we poll the ask ledger instead of holding an in-memory
-        // resolver map. The DB is the single source of truth, so answering is a pure
-        // UPDATE, a crash-orphaned pending row just ends the poll, and an answer that
-        // arrives in a different process than the loop (a hosted deployment) still
-        // lands. A resolver map would be a second state to reconcile and cannot be
-        // resolved once its process dies. Latency is invisible at human decision speed
-        // and can be erased later with LISTEN/NOTIFY.
-        // TODO(refine): these ask records might move into provenance later.
-        for (;;) {
-            if (ctx.signal.aborted) {
-                unwrapOrThrow(await markAborted(pool, id, new Date().toISOString()));
-                await emitAskPart(ctx.emit, id, request, "aborted");
-                throwAbort(ctx.signal);
-            }
-            const resolution = unwrapOrThrow(await selectAskResolution(pool, id));
-            if (resolution === null) {
-                // The row vanished out from under the poll — nothing can answer it
-                // now, so deny rather than spin forever. Not reachable through the
-                // ordinary status machine (rows are only ever updated, never deleted).
-                await emitAskPart(ctx.emit, id, request, "expired");
-                throw new AskRejectedError("approval request is no longer available");
-            }
-            if (resolution.status !== "pending") {
-                await emitAskPart(ctx.emit, id, request, resolution.status, replyKindOf(resolution.status, resolution.reply));
-                return settle(resolution.status, resolution.reply, ctx.signal);
-            }
-            await sleepUntil(POLL_INTERVAL_MS, ctx.signal);
-        }
+        return "pending";
+    }
+    async function expire(id) {
+        unwrapOrThrow(await markExpired(pool, id, new Date().toISOString()));
+    }
+    async function abort(id) {
+        unwrapOrThrow(await markAborted(pool, id, new Date().toISOString()));
     }
     async function answer(id, reply) {
         return unwrapOrThrow(await answerAsk(pool, id, reply, new Date().toISOString()));
@@ -88,79 +50,20 @@ export function createAskGateway(deps) {
         const now = Date.now();
         return unwrapOrThrow(await sweepExpiredRows(pool, new Date(now).toISOString(), new Date(now - maxAgeMs).toISOString()));
     }
-    return { ask, answer, pending, sweepExpired };
+    return { raise, expire, abort, answer, pending, sweepExpired };
 }
-/** Emit (or reconcile, under the same id) the ask's `data-ask` chat part. */
-function emitAskPart(emit, id, request, status, reply) {
-    return emit({
+/** The `data-ask` part of an ask in one status. Each status of one ask reconciles under the same id. */
+export function askPartOf(id, request, status, reply) {
+    const part = {
         type: "data-ask",
-        data: {
-            id,
-            title: request.title,
-            command: request.command,
-            ...(request.detail !== undefined ? { detail: request.detail } : {}),
-            status,
-            ...(reply !== undefined ? { reply } : {}),
-        },
-    });
-}
-/**
- * The kind of reply the terminal part shows: the kind that `settle` acts on for a `resolved` or `rejected` row,
- * and none for any other status. It never reads the feedback of a rejection, which is for the model.
- */
-function replyKindOf(status, reply) {
-    switch (status) {
-        case "resolved":
-            return approvalOf(reply).kind;
-        case "rejected":
-            return "reject";
-        case "expired":
-        case "aborted":
-            return undefined;
-    }
-}
-/** The approval that a `resolved` row grants. */
-function approvalOf(reply) {
-    // Only `once` / `always` reach `resolved`; guard the JSONB round-trip and
-    // default to the narrowest approval if a malformed reply ever slipped in.
-    return reply && (reply.kind === "once" || reply.kind === "always") ? reply : { kind: "once" };
-}
-/** Resolve an approval or throw the terminal denial the ledger recorded. */
-function settle(status, reply, signal) {
-    switch (status) {
-        case "resolved":
-            return approvalOf(reply);
-        case "rejected":
-            throw new AskRejectedError(reply && reply.kind === "reject" ? reply.feedback : undefined);
-        case "expired":
-            throw new AskRejectedError("approval request expired unanswered");
-        case "aborted":
-            throwAbort(signal);
-    }
-}
-/**
- * Re-raise the turn's cancellation verbatim — `signal.reason` IS the loop's own
- * cancellation, so its existing turn-abort path recognizes it unchanged. The
- * fallback covers a signal aborted with no explicit reason.
- */
-function throwAbort(signal) {
-    throw signal.reason ?? new DOMException("The operation was aborted", "AbortError");
-}
-/** Delay `ms`, resolving early if `signal` aborts, leaving no dangling timer. */
-function sleepUntil(ms, signal) {
-    return new Promise((resolve) => {
-        if (signal.aborted) {
-            resolve();
-            return;
-        }
-        const onAbort = () => {
-            clearTimeout(timer);
-            resolve();
-        };
-        const timer = setTimeout(() => {
-            signal.removeEventListener("abort", onAbort);
-            resolve();
-        }, ms);
-        signal.addEventListener("abort", onAbort, { once: true });
-    });
+        id,
+        title: request.title,
+        command: request.command,
+        status,
+    };
+    if (request.detail !== undefined)
+        part.detail = request.detail;
+    if (reply !== undefined)
+        part.reply = reply;
+    return part;
 }

package/dist/tools/approval/queries.d.ts

@@ -18,7 +18,7 @@ export type AskStatus = "pending" | "resolved" | "rejected" | "aborted" | "expir
 /** The discriminated outcome of an out-of-band `answer` against a ledger row. */
 export type AnswerOutcome = "applied" | "not_found" | "already_terminal";
 /** An unresolved ask, as enumerated by `pending()`. */
-export interface PendingAsk {
+export type PendingAsk = {
     readonly id: string;
     readonly analysisId: string;
     readonly userId: string;
@@ -27,14 +27,9 @@ export interface PendingAsk {
     readonly command: string;
     readonly detail: string | null;
     readonly createdAt: string;
-}
-/** The status + recorded reply a poll reads to observe a decision. */
-export interface AskResolution {
-    readonly status: AskStatus;
-    readonly reply: AskReply | null;
-}
+};
 /** Column payload shared by the pending insert and the grant short-circuit insert. */
-export interface AskRow {
+export type AskRow = {
     readonly id: string;
     readonly analysisId: string;
     readonly userId: string;
@@ -45,7 +40,7 @@ export interface AskRow {
     /** Grant key an `always` keys its standing grant under; `null` falls back to `command`. */
     readonly grantKey: string | null;
     readonly createdAt: string;
-}
+};
 /** Insert a fresh `pending` ask before its decision is awaited. */
 export declare function insertPendingAsk(querier: Querier, row: AskRow): ResultAsync<void, DbError>;
 /**
@@ -56,8 +51,8 @@ export declare function insertPendingAsk(querier: Querier, row: AskRow): ResultA
 export declare function insertGrantedAsk(querier: Querier, row: AskRow, resolvedAt: string): ResultAsync<void, DbError>;
 /** Does a standing grant cover `(analysisId, userId, grantKey)` for this person? */
 export declare function selectGrant(querier: Querier, analysisId: string, userId: string, grantKey: string): ResultAsync<boolean, DbError>;
-/** Read a row's current status + recorded reply. `null` when no such row exists. */
-export declare function selectAskResolution(querier: Querier, id: string): ResultAsync<AskResolution | null, DbError>;
+/** Mark a still-`pending` row `expired`. A row that an answer settled does not change. */
+export declare function markExpired(querier: Querier, id: string, resolvedAt: string): ResultAsync<void, DbError>;
 /**
  * Mark a still-`pending` row `aborted`. Guarded by `WHERE status = 'pending'`, so
  * a row already answered out of band is left untouched.

package/dist/tools/approval/queries.js

@@ -9,14 +9,29 @@
  * seam boundary.
  */
 import { okAsync } from "neverthrow";
+import { z } from "zod";
 import { tryMutation, tryQuery, withTransaction } from "../../lib/db-result.js";
+/** The columns of the pending enumeration, as the SELECT spells them. */
+const PendingAskRowSchema = z.object({
+    id: z.string(),
+    analysis_id: z.string(),
+    user_id: z.string(),
+    thread_id: z.string().nullable(),
+    title: z.string(),
+    command: z.string(),
+    detail: z.string().nullable(),
+    created_at: z.string(),
+});
+/** The columns the guarded UPDATE returns for the standing-grant insert. */
+const GrantedRowSchema = z.object({ analysis_id: z.string(), user_id: z.string(), grant_key: z.string() });
 /** Insert a fresh `pending` ask before its decision is awaited. */
 export function insertPendingAsk(querier, row) {
     return tryMutation("asks.insertPending", async () => {
         await querier.query({
             text: `INSERT INTO cortex_asks
               (id, analysis_id, user_id, thread_id, title, command, detail, grant_key, status, created_at)
-              VALUES ($1, $2, $3, $4, $5, $6, $7, $8, 'pending', $9)`,
+              VALUES ($1, $2, $3, $4, $5, $6, $7, $8, 'pending', $9)
+              ON CONFLICT (id) DO NOTHING`,
             values: [row.id, row.analysisId, row.userId, row.threadId, row.title, row.command, row.detail, row.grantKey ?? row.command, row.createdAt],
         });
     });
@@ -31,7 +46,8 @@ export function insertGrantedAsk(querier, row, resolvedAt) {
         await querier.query({
             text: `INSERT INTO cortex_asks
               (id, analysis_id, user_id, thread_id, title, command, detail, grant_key, status, reply, created_at, resolved_at)
-              VALUES ($1, $2, $3, $4, $5, $6, $7, $8, 'resolved', $9::jsonb, $10, $11)`,
+              VALUES ($1, $2, $3, $4, $5, $6, $7, $8, 'resolved', $9::jsonb, $10, $11)
+              ON CONFLICT (id) DO NOTHING`,
             values: [
                 row.id,
                 row.analysisId,
@@ -58,17 +74,13 @@ export function selectGrant(querier, analysisId, userId, grantKey) {
         return (result.rowCount ?? 0) > 0;
     });
 }
-/** Read a row's current status + recorded reply. `null` when no such row exists. */
-export function selectAskResolution(querier, id) {
-    return tryQuery("asks.selectResolution", async () => {
-        const result = await querier.query({
-            text: `SELECT status, reply FROM cortex_asks WHERE id = $1`,
-            values: [id],
+/** Mark a still-`pending` row `expired`. A row that an answer settled does not change. */
+export function markExpired(querier, id, resolvedAt) {
+    return tryMutation("asks.markExpired", async () => {
+        await querier.query({
+            text: `UPDATE cortex_asks SET status = 'expired', resolved_at = $2 WHERE id = $1 AND status = 'pending'`,
+            values: [id, resolvedAt],
         });
-        const row = result.rows[0];
-        if (!row)
-            return null;
-        return { status: row.status, reply: row.reply ?? null };
     });
 }
 /**
@@ -90,16 +102,19 @@ export function selectPending(querier) {
             text: `SELECT id, analysis_id, COALESCE(user_id, '') AS user_id, thread_id, title, command, detail, created_at
               FROM cortex_asks WHERE status = 'pending' ORDER BY created_at ASC`,
         });
-        return result.rows.map((row) => ({
-            id: row.id,
-            analysisId: row.analysis_id,
-            userId: row.user_id,
-            threadId: row.thread_id ?? null,
-            title: row.title,
-            command: row.command,
-            detail: row.detail ?? null,
-            createdAt: row.created_at,
-        }));
+        return result.rows.map((row) => {
+            const parsed = PendingAskRowSchema.parse(row);
+            return {
+                id: parsed.id,
+                analysisId: parsed.analysis_id,
+                userId: parsed.user_id,
+                threadId: parsed.thread_id ?? null,
+                title: parsed.title,
+                command: parsed.command,
+                detail: parsed.detail ?? null,
+                createdAt: parsed.created_at,
+            };
+        });
     });
 }
 /**
@@ -142,14 +157,13 @@ export function answerAsk(pool, id, reply, now) {
             return discriminateMiss(client, id);
         if (reply.kind !== "always")
             return okAsync("applied");
-        // The cast's non-null `grant_key` is sound without any boot-order
-        // caveat: every insert writes grant_key (command when the tool supplied
-        // none), and the COALESCE above covers any pending row that predates
-        // the column — `command` is NOT NULL, so the key can never be null.
-        // `user_id` reads the same way: its COALESCE gives the empty string for a
-        // row that predates the column, and that identity matches no real user.
-        const granted = updated.rows[0];
+        // The COALESCEs make every returned field non-null: each insert writes
+        // grant_key (command when the tool supplied none) and user_id (empty
+        // string when the row predates the column), so the row schema below can
+        // demand all three strings; a row that misses one is refused through the
+        // transaction's `DbError` channel.
         return tryMutation("asks.answer:grant", async () => {
+            const granted = GrantedRowSchema.parse(updated.rows[0]);
             await client.query({
                 text: `INSERT INTO cortex_ask_grants (analysis_id, user_id, grant_key, created_at)
                       VALUES ($1, $2, $3, $4) ON CONFLICT (analysis_id, user_id, grant_key) DO NOTHING`,

package/dist/tools/approval/uuidv7.js

@@ -18,8 +18,8 @@ export function uuidv7() {
     // in 48 bits well past the year 10000, so writeUIntBE never overflows.
     bytes.writeUIntBE(Date.now(), 0, 6);
     // Version 7 in the high nibble of byte 6; variant 0b10 in the top bits of byte 8.
-    bytes[6] = (bytes[6] & 0x0f) | 0x70;
-    bytes[8] = (bytes[8] & 0x3f) | 0x80;
+    bytes.writeUInt8((bytes.readUInt8(6) & 0x0f) | 0x70, 6);
+    bytes.writeUInt8((bytes.readUInt8(8) & 0x3f) | 0x80, 8);
     const hex = bytes.toString("hex");
     return `${hex.slice(0, 8)}-${hex.slice(8, 12)}-${hex.slice(12, 16)}-${hex.slice(16, 20)}-${hex.slice(20)}`;
 }

package/dist/tools/bio/chembl.d.ts

@@ -28,11 +28,11 @@ export type ChemblOutput = {
     readonly targets: ChemblTarget[];
 };
 export declare const chemblTool: import("../define-tool.js").Tool<{
-    action: "drug" | "targets" | "compounds" | "mechanism" | "bioactivity";
+    action: "bioactivity" | "compounds" | "drug" | "mechanism" | "targets";
     query?: string | undefined;
-    searchType?: "target" | "smiles" | "compound" | undefined;
+    searchType?: "compound" | "smiles" | "target" | undefined;
     chemblId?: string | undefined;
-    idType?: "target" | "compound" | "assay" | undefined;
+    idType?: "assay" | "compound" | "target" | undefined;
     activityType?: string | undefined;
     limit?: number | undefined;
 }, ChemblOutput>;

package/dist/tools/bio/chembl.js

@@ -131,14 +131,24 @@ export const chemblTool = defineTool({
     execute: async ({ action, query, searchType, chemblId, idType, activityType, limit }) => {
         switch (action) {
             case "compounds":
+                if (query === undefined || searchType === undefined)
+                    throw new Error("compounds requires query and searchType");
                 return ok({ compounds: await searchCompounds(query, searchType, limit ?? LIMITS.wideDefault) });
             case "drug":
+                if (query === undefined)
+                    throw new Error("drug requires query");
                 return ok({ drugs: await getDrugInfo(query, limit ?? LIMITS.narrowDefault) });
             case "mechanism":
+                if (chemblId === undefined)
+                    throw new Error("mechanism requires chemblId");
                 return ok({ mechanisms: await getMechanism(chemblId) });
             case "bioactivity":
+                if (chemblId === undefined || idType === undefined)
+                    throw new Error("bioactivity requires chemblId and idType");
                 return ok({ activities: await getBioactivity(chemblId, idType, { activityType, limit: limit ?? LIMITS.wideDefault }) });
             case "targets":
+                if (query === undefined)
+                    throw new Error("targets requires query");
                 return ok({ targets: await searchTargets(query, limit ?? LIMITS.narrowDefault) });
         }
     },

package/dist/tools/bio/comptox.d.ts

@@ -14,7 +14,31 @@
  * dataset (a 'toxval' under dataset 'exposure' would otherwise silently fetch
  * nothing) and a limit above the dataset's own ceiling.
  */
+import { z } from "zod";
+import { type Tool } from "../define-tool.js";
 import { type ChemicalDetail, type CtxExposureData, type CtxHazardData, type PropertySummary, type ToxcastBioactivity } from "../lib/ctx-ops.js";
+declare const inputSchema: z.ZodObject<{
+    dataset: z.ZodEnum<{
+        chemical: "chemical";
+        exposure: "exposure";
+        hazard: "hazard";
+        toxcast: "toxcast";
+    }>;
+    query: z.ZodString;
+    dataType: z.ZodOptional<z.ZodEnum<{
+        all: "all";
+        cancer: "cancer";
+        "functional-use": "functional-use";
+        genetox: "genetox";
+        httk: "httk";
+        "product-data": "product-data";
+        seem: "seem";
+        toxval: "toxval";
+    }>>;
+    activeOnly: z.ZodOptional<z.ZodBoolean>;
+    includeProperties: z.ZodOptional<z.ZodBoolean>;
+    limit: z.ZodOptional<z.ZodNumber>;
+}, z.core.$strip>;
 type ComptoxOutput = {
     found: false;
     query: string;
@@ -39,12 +63,5 @@ type ComptoxOutput = {
 } & CtxExposureData);
 export declare function createComptoxTool(deps: {
     apiKey: string;
-}): import("../define-tool.js").Tool<{
-    dataset: "toxcast" | "hazard" | "chemical" | "exposure";
-    query: string;
-    dataType?: "toxval" | "genetox" | "cancer" | "all" | "seem" | "httk" | "functional-use" | "product-data" | undefined;
-    activeOnly?: boolean | undefined;
-    includeProperties?: boolean | undefined;
-    limit?: number | undefined;
-}, ComptoxOutput>;
+}): Tool<z.infer<typeof inputSchema>, ComptoxOutput>;
 export {};

package/dist/tools/bio/comptox.js

@@ -21,11 +21,13 @@ import { fetchCtxChemicalDetail, fetchCtxChemicalProperties, fetchCtxExposureDat
 import { getEpaCcteHeaders } from "../lib/toxcast-config.js";
 const HAZARD_DATA_TYPES = ["toxval", "genetox", "cancer", "all"];
 const EXPOSURE_DATA_TYPES = ["seem", "httk", "functional-use", "product-data", "all"];
+const HAZARD_DATA_TYPE_IDS = new Set(HAZARD_DATA_TYPES);
+const EXPOSURE_DATA_TYPE_IDS = new Set(EXPOSURE_DATA_TYPES);
 function isHazardDataType(value) {
-    return value !== undefined && HAZARD_DATA_TYPES.includes(value);
+    return value !== undefined && HAZARD_DATA_TYPE_IDS.has(value);
 }
 function isExposureDataType(value) {
-    return value !== undefined && EXPOSURE_DATA_TYPES.includes(value);
+    return value !== undefined && EXPOSURE_DATA_TYPE_IDS.has(value);
 }
 const inputSchema = z
     .object({

package/dist/tools/bio/drug-gene-interactions.d.ts

@@ -16,49 +16,59 @@
  * Each source runs independently and reports its own outcome in `perSource`, so
  * a missing DrugBank key degrades that corpus rather than the whole call.
  */
+import { z } from "zod";
 import type { Logger } from "../../lib/logger.js";
+import { type Tool } from "../define-tool.js";
 import { type DgidbResult } from "../lib/dgidb-client.js";
 import { type PharmgkbAnnotation } from "../lib/pharmgkb-client.js";
 declare const SOURCES: readonly ["dgidb", "drugbank", "pharmgkb"];
 type Source = (typeof SOURCES)[number];
-interface SourceOutcome {
+type SourceOutcome = {
     source: Source;
     status: "ok" | "no_data" | "unavailable";
     returned: number;
     detail?: string;
-}
+};
 /**
  * A DrugBank record projected for context. `includeDrugRecord` decides whether
  * the description arrives whole or as a preview — a 500-character field across
  * ten records is narrative that a drug-vs-gene question rarely needs.
  */
-interface ProjectedDrug {
+type ProjectedDrug = {
     drugbankId: string;
     name: string;
     type: string;
     groups: string[];
     description: string;
     proseTruncated: boolean;
-}
-interface DrugGeneOutput {
+};
+declare const inputSchema: z.ZodObject<{
+    query: z.ZodUnion<readonly [z.ZodString, z.ZodArray<z.ZodString>]>;
+    direction: z.ZodEnum<{
+        drug_to_genes: "drug_to_genes";
+        gene_to_drugs: "gene_to_drugs";
+    }>;
+    sources: z.ZodOptional<z.ZodArray<z.ZodEnum<{
+        dgidb: "dgidb";
+        drugbank: "drugbank";
+        pharmgkb: "pharmgkb";
+    }>>>;
+    limit: z.ZodOptional<z.ZodNumber>;
+    interactionTypes: z.ZodOptional<z.ZodArray<z.ZodString>>;
+    sourceDbs: z.ZodOptional<z.ZodArray<z.ZodString>>;
+    minSources: z.ZodOptional<z.ZodNumber>;
+    includeAttributes: z.ZodOptional<z.ZodBoolean>;
+    includeDrugRecord: z.ZodOptional<z.ZodBoolean>;
+}, z.core.$strip>;
+type DrugGeneOutput = {
     direction: "gene_to_drugs" | "drug_to_genes";
     perSource: SourceOutcome[];
     dgidb?: DgidbResult[];
     drugbank?: ProjectedDrug[];
     pharmgkb?: PharmgkbAnnotation[];
-}
+};
 export declare function createDrugGeneInteractionsTool(deps: {
     drugbankApiKey: string;
     logger?: Logger;
-}): import("../define-tool.js").Tool<{
-    query: string | string[];
-    direction: "gene_to_drugs" | "drug_to_genes";
-    sources?: ("dgidb" | "drugbank" | "pharmgkb")[] | undefined;
-    limit?: number | undefined;
-    interactionTypes?: string[] | undefined;
-    sourceDbs?: string[] | undefined;
-    minSources?: number | undefined;
-    includeAttributes?: boolean | undefined;
-    includeDrugRecord?: boolean | undefined;
-}, DrugGeneOutput>;
+}): Tool<z.infer<typeof inputSchema>, DrugGeneOutput>;
 export {};

package/dist/tools/bio/drug-gene-interactions.js

@@ -16,7 +16,10 @@
  * Each source runs independently and reports its own outcome in `perSource`, so
  * a missing DrugBank key degrades that corpus rather than the whole call.
  */
+import { errorMessageOf } from "../../lib/thrown.js";
+import { textOf } from "../../lib/unknown-text.js";
 import { ok } from "neverthrow";
+import { presentFirst } from "../../lib/present.js";
 import { z } from "zod";
 import { createNoopLogger } from "../../lib/console-logger.js";
 import { defineTool } from "../define-tool.js";
@@ -94,7 +97,7 @@ async function runSource(source, fetch) {
     }
     catch (error) {
         return {
-            outcome: { source, status: "unavailable", returned: 0, detail: error instanceof Error ? error.message : String(error) },
+            outcome: { source, status: "unavailable", returned: 0, detail: errorMessageOf(error) ?? textOf(error) },
             records: [],
         };
     }
@@ -126,30 +129,30 @@ export function createDrugGeneInteractionsTool(deps) {
                 selected.includes("dgidb")
                     ? runSource("dgidb", () => searchDgidb(inputs, isGeneSide ? "gene" : "drug", {
                         limit,
-                        ...(input.interactionTypes ? { interactionTypes: input.interactionTypes } : {}),
-                        ...(input.sourceDbs ? { sourceDbs: input.sourceDbs } : {}),
-                        ...(input.minSources !== undefined ? { minSources: input.minSources } : {}),
-                        ...(input.includeAttributes !== undefined ? { includeAttributes: input.includeAttributes } : {}),
+                        interactionTypes: input.interactionTypes ? input.interactionTypes : undefined,
+                        sourceDbs: input.sourceDbs ? input.sourceDbs : undefined,
+                        minSources: input.minSources,
+                        includeAttributes: input.includeAttributes,
                     }, (errors) => logger.warn("dgidb partial errors alongside data", { errors })))
                     : null,
                 selected.includes("drugbank")
                     ? runSource("drugbank", async () => {
                         if (!deps.drugbankApiKey)
                             throw new Error("DRUGBANK_API_KEY is not configured");
-                        const drugs = await searchDrugbank(deps.drugbankApiKey, inputs[0], isGeneSide ? "target" : "drug", limit);
+                        const drugs = await searchDrugbank(deps.drugbankApiKey, presentFirst(inputs, "the first input"), isGeneSide ? "target" : "drug", limit);
                         return drugs.map((d) => projectDrug(d, input.includeDrugRecord ?? false));
                     })
                     : null,
                 selected.includes("pharmgkb")
                     ? runSource("pharmgkb", async () => {
-                        const res = await searchPharmgkb(inputs[0], isGeneSide ? "gene" : "drug", limit);
+                        const res = await searchPharmgkb(presentFirst(inputs, "the first input"), isGeneSide ? "gene" : "drug", limit);
                         return res.annotations;
                     })
                     : null,
             ]);
             // DrugBank and PharmGKB take one identifier per call; say so on the
             // outcome rather than letting the extra inputs vanish silently.
-            const skipped = inputs.length > 1 ? `read only '${inputs[0]}' — this source takes one identifier per call` : "";
+            const skipped = inputs.length > 1 ? `read only '${String(inputs[0])}' — this source takes one identifier per call` : "";
             const noteSkipped = (outcome) => {
                 const detail = [outcome.detail, skipped].filter(Boolean).join("; ");
                 return detail ? { ...outcome, detail } : outcome;