@inflexa-ai/harness 0.1.1

package/dist/tools/research/generate-plan.js

@@ -0,0 +1,393 @@
+/**
+ * generatePlan — a loop-driving tool: a focused `runAgent` loop that builds
+ * an analysis plan (a DAG of steps).
+ *
+ * The outer tool receives structured context from the conversation agent
+ * (data profile, research question, prior runs, constraints) and drives an
+ * internal "planner" agent that communicates outcomes EXCLUSIVELY via four
+ * terminal tool calls:
+ *
+ *   - validate_plan(plan)       → non-terminal dry-run (Zod + semantic)
+ *   - submit_plan(plan)         → terminal success: re-validates + persists
+ *   - request_clarification(…)  → terminal: planner needs more context
+ *   - report_blocker(reason)    → terminal: no viable plan
+ *
+ * The planner is an `AgentDefinition` driven by `runAgent`; the pool and
+ * resource id are an explicit `Pool` dependency and the request-scoped
+ * `Session`. The planner prompt injects the agent catalog and exposes the
+ * terminal-tool surface above.
+ */
+import { ok } from "neverthrow";
+import { z } from "zod";
+import { formatAgentCatalog } from "../../agents/sandbox-catalog.js";
+import { runToTerminal } from "../../loop/run-to-terminal.js";
+import { passthroughStep } from "../../loop/run-step.js";
+import { forSubAgent, scopeResource } from "../../auth/types.js";
+import { defineTool } from "../define-tool.js";
+import { DEFAULT_SANDBOX_MAX_STEPS } from "../../config/resource-limits.js";
+import { plannerPrompt } from "../../prompts/planner.js";
+import { hydratePlanSteps, PlannerPlanSchema } from "../../schemas/plan-schemas.js";
+import { validatePlan } from "../../schemas/validate-plan.js";
+import { AnalysisPlanSchema } from "../../schemas/workflow-state.js";
+import { unwrapOrThrow } from "../../lib/result.js";
+import { insertPlan, loadPlan } from "../../state/index.js";
+// ── Tool-level config ──────────────────────────────────────────────
+/** Sub-agent identity for the planner — provenance only. */
+const PLANNER_AGENT_ID = "planner";
+/**
+ * Budget for the planner's internal loop: 1 draft + ~3 validate/fix
+ * cycles + 1 submit + headroom.
+ */
+const PLANNER_MAX_ITERATIONS = 13;
+/** Wall-clock guard for a single plan-generation invocation. */
+const PLAN_TIMEOUT_MS = 600_000;
+// ── Prompt / catalog ────────────────────────────────────────────────
+/** The planner system prompt is deterministic per policy — build it once per
+ *  factory (the policy is a construction-time dep, fixed for the process). */
+function plannerInstructions(resourcePolicy) {
+    return plannerPrompt(formatAgentCatalog(), resourcePolicy);
+}
+// ── Prior plan serialization (iteration context) ───────────────────
+/**
+ * Format a loaded prior plan as a markdown block the planner can read —
+ * narrative + one line per step. Used only when `parentPlanId` is set.
+ */
+function formatPriorPlan(parentPlanId, plan) {
+    const parsed = AnalysisPlanSchema.safeParse(plan);
+    if (!parsed.success)
+        return null;
+    const p = parsed.data;
+    const stepLines = p.steps.map((s) => {
+        const deps = s.depends_on.length ? ` [deps: ${s.depends_on.join(", ")}]` : "";
+        const agent = s.agent ? ` (${s.agent})` : "";
+        return `- **${s.id}**${agent}: ${s.name} — ${s.question}${deps}`;
+    });
+    return [
+        `## Prior Plan (${parentPlanId} — being iterated)`,
+        "",
+        ...(p.analytical_narrative ? [`**Analytical narrative:** ${p.analytical_narrative}`, ""] : []),
+        "**Steps:**",
+        ...stepLines,
+        "",
+        "The user is iterating on this plan. Preserve steps and IDs that are " +
+            "not being changed; modify only what `userConstraints` describes. " +
+            "Reuse step IDs when a step's purpose is unchanged so downstream " +
+            "references survive.",
+    ].join("\n");
+}
+// ── Persistence ─────────────────────────────────────────────────────
+/**
+ * Persist a validated plan. Returns the planId, or an outcome-ready error
+ * with a sanitized message — DB-shape errors never leak to the planner.
+ */
+async function persistPlan(plan, ctx, pool) {
+    try {
+        const planId = unwrapOrThrow(await insertPlan(pool, {
+            analysisId: ctx.analysisId,
+            plan: hydratePlanSteps(plan),
+            parentPlanId: ctx.parentPlanId,
+        }));
+        return { ok: true, planId };
+    }
+    catch (err) {
+        const raw = err instanceof Error ? err.message : String(err);
+        const isParentValidation = /^parent plan .* (?:not found|belongs to a different analysis)$/i.test(raw);
+        return {
+            ok: false,
+            message: isParentValidation ? "parentPlanId is not a valid plan for this analysis" : "plan could not be saved, please try again",
+        };
+    }
+}
+// ── Validation ──────────────────────────────────────────────────────
+function zodIssuesToValidationIssues(error, rootPath = "plan") {
+    return error.issues.map((i) => ({
+        path: [rootPath, ...i.path.map((p) => String(p))].join("."),
+        code: "schema",
+        message: i.message,
+    }));
+}
+/**
+ * Full validation: Zod schema + semantic checks. The plan is valid only if
+ * BOTH pass.
+ */
+function fullyValidate(candidate, resourcePolicy) {
+    const parsed = PlannerPlanSchema.safeParse(candidate);
+    if (!parsed.success) {
+        return { valid: false, issues: zodIssuesToValidationIssues(parsed.error) };
+    }
+    // Semantic checks operate on the AnalysisPlan shape — PlannerPlan omits
+    // maxSteps, so inject the execution-time default to satisfy the validator.
+    const semantic = validatePlan({
+        analytical_narrative: parsed.data.analytical_narrative,
+        steps: parsed.data.steps.map((s) => ({
+            ...s,
+            status: "pending",
+            maxSteps: DEFAULT_SANDBOX_MAX_STEPS,
+        })),
+        created_at: parsed.data.created_at,
+        omicsType: parsed.data.omicsType,
+        omicsSubtype: parsed.data.omicsSubtype,
+    }, { perStepCeiling: resourcePolicy?.perStep });
+    if (!semantic.valid) {
+        return {
+            valid: false,
+            issues: semantic.errors.map((msg) => ({
+                path: "plan",
+                code: "semantic",
+                message: msg,
+            })),
+        };
+    }
+    return { valid: true, plan: parsed.data };
+}
+/**
+ * Build the planner's inner tools for one invocation. They close over the
+ * shared `holder` so the outer `execute` reads the terminal outcome after the
+ * loop finishes.
+ */
+function buildInnerTools(holder, persistCtx, pool, resourcePolicy) {
+    const candidatePlan = z.object({ plan: z.unknown() });
+    const validatePlanTool = defineTool({
+        id: "validate_plan",
+        description: "Dry-run a candidate plan against the schema and semantic checks " +
+            "(agent IDs, DAG cycles, dependency references, unique step IDs, " +
+            "resources). Returns {valid, issues}. Non-terminal — call as many " +
+            "times as needed to iterate toward a clean plan before submit_plan.",
+        inputSchema: candidatePlan,
+        execute: async (input) => {
+            const result = fullyValidate(input.plan, resourcePolicy);
+            return ok(result.valid ? { valid: true, issues: [] } : { valid: false, issues: result.issues });
+        },
+    });
+    const submitPlanTool = defineTool({
+        id: "submit_plan",
+        description: "Submit the final plan for persistence. Re-validates the plan; on " +
+            "success returns {accepted: true, planId} — STOP after this. On " +
+            "rejection returns {accepted: false, issues} — fix and call again, " +
+            "or switch to report_blocker if the plan cannot be made valid.",
+        inputSchema: candidatePlan,
+        execute: async (input) => {
+            if (holder.outcome !== null) {
+                return ok({
+                    accepted: false,
+                    issues: [
+                        {
+                            path: "plan",
+                            code: "semantic",
+                            message: "A terminal outcome has already been recorded; submit_plan " + "can only be called once per invocation.",
+                        },
+                    ],
+                });
+            }
+            const result = fullyValidate(input.plan, resourcePolicy);
+            if (!result.valid) {
+                return ok({ accepted: false, issues: result.issues });
+            }
+            const persisted = await persistPlan(result.plan, persistCtx, pool);
+            if (!persisted.ok) {
+                holder.outcome = { kind: "persist_error", message: persisted.message };
+                return ok({
+                    accepted: false,
+                    issues: [
+                        {
+                            path: "plan",
+                            code: "semantic",
+                            message: persisted.message,
+                            hint: "Persistence failed — do not retry submit_plan.",
+                        },
+                    ],
+                });
+            }
+            holder.outcome = {
+                kind: "plan_submitted",
+                planId: persisted.planId,
+                plan: result.plan,
+            };
+            return ok({ accepted: true, planId: persisted.planId });
+        },
+    });
+    const requestClarificationTool = defineTool({
+        id: "request_clarification",
+        description: "Terminal. Use when a specific fact you need is missing from the " +
+            "input and cannot be inferred. Pass a short question and optional " +
+            "context. Stop after calling.",
+        inputSchema: z.object({
+            question: z.string().min(1),
+            questionContext: z.string().optional(),
+        }),
+        execute: async (input) => {
+            if (holder.outcome === null) {
+                holder.outcome = {
+                    kind: "clarification",
+                    question: input.question,
+                    questionContext: input.questionContext,
+                };
+            }
+            return ok({ recorded: true });
+        },
+    });
+    const reportBlockerTool = defineTool({
+        id: "report_blocker",
+        description: "Terminal. Use when no valid plan can be produced (out of scope, " +
+            "data incompatible with every available agent, etc.). Pass a short " +
+            "reason. Stop after calling.",
+        inputSchema: z.object({ reason: z.string().min(1) }),
+        execute: async (input) => {
+            if (holder.outcome === null) {
+                holder.outcome = { kind: "blocker", reason: input.reason };
+            }
+            return ok({ recorded: true });
+        },
+    });
+    const terminal = [submitPlanTool, requestClarificationTool, reportBlockerTool];
+    return { all: [validatePlanTool, ...terminal], terminal };
+}
+/**
+ * Translate the captured `PlannerOutcome` (plus any loop error) into the
+ * `PlanningAgentOutput` contract the conversation agent consumes.
+ */
+function shapeOutcome(args) {
+    const { holder, runError, timedOut, outerAborted } = args;
+    const outcome = holder.outcome;
+    if (outcome?.kind === "plan_submitted") {
+        return { event: "plan_complete", planId: outcome.planId, plan: outcome.plan };
+    }
+    if (outcome?.kind === "clarification") {
+        return {
+            event: "clarification_needed",
+            question: outcome.question,
+            ...(outcome.questionContext ? { questionContext: outcome.questionContext } : {}),
+        };
+    }
+    if (outcome?.kind === "blocker") {
+        return { event: "error", error: outcome.reason };
+    }
+    if (outcome?.kind === "persist_error") {
+        return { event: "error", error: `Failed to save plan: ${outcome.message}` };
+    }
+    // No terminal outcome — something went wrong in the loop.
+    if (timedOut) {
+        return {
+            event: "error",
+            error: "Plan generation timed out — the model may be overloaded.",
+        };
+    }
+    if (outerAborted) {
+        return { event: "error", error: "Plan generation was cancelled." };
+    }
+    if (runError) {
+        const msg = runError instanceof Error ? runError.message : String(runError);
+        return { event: "error", error: `Plan generation failed: ${msg}` };
+    }
+    return {
+        event: "error",
+        error: "Plan generation completed without a terminal outcome — the planner " + "did not call submit_plan, request_clarification, or report_blocker.",
+    };
+}
+/** Build the `generate_plan` tool bound to its provider and pool. */
+export function createGeneratePlanTool(deps) {
+    return defineTool({
+        id: "generate_plan",
+        description: "Generate an analysis plan (DAG of steps) for the given data context " +
+            "and research question. Pass all relevant context: data profile " +
+            "summary, omics type, experimental design, prior run results, and " +
+            "user constraints. Returns a structured plan ready for show_plan and " +
+            "execute_plan, or a clarification question if context is insufficient.",
+        inputSchema: z.object({
+            dataContext: z
+                .string()
+                .describe("Data profile summary: data type, modality, file descriptions, " + "feature/sample counts, experimental design, condition names."),
+            researchQuestion: z.string().describe("What the user wants to analyze — their goal and specific questions."),
+            priorRuns: z
+                .string()
+                .optional()
+                .describe("Summary of prior run results if any exist: which steps ran, " + "what succeeded/failed, key findings. Omit if no prior runs."),
+            userConstraints: z
+                .string()
+                .optional()
+                .describe("User-specified constraints: preferred methods, steps to " + "include/exclude, resource limits, modifications to a prior plan."),
+            parentPlanId: z
+                .string()
+                .regex(/^pln-[a-f0-9]{8}$/, "parentPlanId must be a pln-<8hex> value")
+                .optional()
+                .describe("The planId of the prior plan being iterated on. Set only when " + "the user is asking for modifications to an existing plan."),
+        }),
+        execute: async (input, ctx) => {
+            const analysisId = scopeResource(ctx.session.scope).resourceId;
+            // If iterating, load the parent plan so the planner sees what it is
+            // revising. Fails fast with the sanitized message submit_plan would
+            // have surfaced — saves a wasted planner run.
+            let priorPlanBlock = null;
+            if (input.parentPlanId) {
+                try {
+                    const priorPlan = unwrapOrThrow(await loadPlan(deps.pool, input.parentPlanId, {
+                        analysisId,
+                    }));
+                    if (!priorPlan) {
+                        return ok({
+                            event: "error",
+                            error: "parentPlanId is not a valid plan for this analysis",
+                        });
+                    }
+                    priorPlanBlock = formatPriorPlan(input.parentPlanId, priorPlan);
+                }
+                catch {
+                    return ok({
+                        event: "error",
+                        error: "Plan iteration failed — parent plan could not be loaded.",
+                    });
+                }
+            }
+            const prompt = [
+                ...(priorPlanBlock ? [priorPlanBlock, ""] : []),
+                "## Data Context",
+                input.dataContext,
+                "",
+                "## Research Question",
+                input.researchQuestion,
+                ...(input.priorRuns ? ["", "## Prior Run Results", input.priorRuns] : []),
+                ...(input.userConstraints ? ["", "## User Constraints", input.userConstraints] : []),
+            ].join("\n");
+            const holder = { outcome: null };
+            const persistCtx = {
+                analysisId,
+                parentPlanId: input.parentPlanId ?? null,
+            };
+            const innerTools = buildInnerTools(holder, persistCtx, deps.pool, deps.resourcePolicy);
+            const planner = {
+                id: PLANNER_AGENT_ID,
+                systemPrompt: plannerInstructions(deps.resourcePolicy),
+                model: deps.model,
+                tools: innerTools.all,
+                maxIterations: PLANNER_MAX_ITERATIONS,
+            };
+            // Merge the outer abort signal with a wall-clock timeout — either
+            // cancels the planner promptly.
+            const signal = AbortSignal.any([ctx.signal, AbortSignal.timeout(PLAN_TIMEOUT_MS)]);
+            let runError = null;
+            try {
+                await runToTerminal(planner, [{ role: "user", content: prompt }], forSubAgent(ctx.session, PLANNER_AGENT_ID), {
+                    provider: deps.provider,
+                    signal,
+                    emit: ctx.emit,
+                    runStep: passthroughStep,
+                }, {
+                    resolved: () => holder.outcome !== null,
+                    tools: innerTools.terminal,
+                    nudge: "You ended without a terminal outcome. Call submit_plan with " +
+                        "your final plan now, or request_clarification / report_blocker " +
+                        "if you cannot. Do not reply with prose.",
+                });
+            }
+            catch (err) {
+                runError = err;
+            }
+            return ok(shapeOutcome({
+                holder,
+                runError,
+                timedOut: signal.aborted && !ctx.signal.aborted,
+                outerAborted: ctx.signal.aborted,
+            }));
+        },
+    });
+}

package/dist/tools/research/index.d.ts

@@ -0,0 +1,15 @@
+/**
+ * Research barrel — dependency-bearing planning, run inspection, the
+ * literature-reviewer and analogical-reasoner sub-agents, developer-docs
+ * lookup, and the cross-domain search tools the analogical-reasoner uses.
+ * Dep-bearing tools are factory closures (`createXTool(deps)`); pure tools
+ * are module-scope `defineTool` values.
+ */
+export * from "./generate-plan.js";
+export * from "./inspect-run.js";
+export * from "./literature-reviewer.js";
+export * from "./generate-analogy-report.js";
+export * from "./context7-docs.js";
+export * from "./search-semantic-scholar.js";
+export * from "./search-arxiv.js";
+export * from "./search-github-repos.js";

package/dist/tools/research/index.js

@@ -0,0 +1,15 @@
+/**
+ * Research barrel — dependency-bearing planning, run inspection, the
+ * literature-reviewer and analogical-reasoner sub-agents, developer-docs
+ * lookup, and the cross-domain search tools the analogical-reasoner uses.
+ * Dep-bearing tools are factory closures (`createXTool(deps)`); pure tools
+ * are module-scope `defineTool` values.
+ */
+export * from "./generate-plan.js";
+export * from "./inspect-run.js";
+export * from "./literature-reviewer.js";
+export * from "./generate-analogy-report.js";
+export * from "./context7-docs.js";
+export * from "./search-semantic-scholar.js";
+export * from "./search-arxiv.js";
+export * from "./search-github-repos.js";

package/dist/tools/research/inspect-run.d.ts

@@ -0,0 +1,54 @@
+/**
+ * inspectRun — inspect workflow runs for the current analysis.
+ *
+ * Dependency-bearing: the database `Pool` is captured by the factory
+ * (see the harness-durable-runtime spec). The analysis id is read from the request-scoped `Session`,
+ * not an ambient request context.
+ *
+ * Results are pull-only via this tool — the workflow does NOT write to the
+ * conversation thread on completion. The retired `run-result-writer` push
+ * payload (run status, step summaries, run synthesis, artifact paths) is
+ * surfaced here on demand: the run row + step `summaryPath` references +
+ * the `synthesisPath` for completed runs let the conversation agent
+ * `read_file` the artefacts it needs.
+ */
+import type { Pool } from "pg";
+import type { CortexRunRow } from "../../state/schema.js";
+type FormattedRun = ReturnType<typeof formatRun>;
+interface FormattedStep {
+    stepId: string;
+    agentId: string;
+    wave: number;
+    status: string;
+    /** Absent for steps that never ran (`pending`/`skipped`) — no output tree exists to point at. */
+    summaryPath?: string;
+    durationMs?: number | null;
+    error?: string | null;
+    attempts?: number | null;
+    lastErrorClass?: string | null;
+    finishReason?: string | null;
+    hitMaxSteps?: boolean | null;
+}
+type InspectRunOutput = {
+    message: string;
+} | {
+    runs: FormattedRun[];
+} | {
+    run: FormattedRun;
+    steps: FormattedStep[];
+};
+declare function formatRun(r: CortexRunRow, verbose: boolean): {
+    error?: string | null | undefined;
+    runId: string;
+    workflowName: string;
+    status: "running" | "completed" | "failed" | "partial" | "canceled" | "suspended_insufficient_funds";
+    startedAt: string;
+    completedAt: string | null;
+    planId: string | null;
+    synthesisPath: string | null;
+};
+export declare function createInspectRunTool(pool: Pool): import("../define-tool.js").Tool<{
+    runId?: string | undefined;
+    includeDiagnostics?: boolean | undefined;
+}, InspectRunOutput>;
+export {};

package/dist/tools/research/inspect-run.js

@@ -0,0 +1,85 @@
+/**
+ * inspectRun — inspect workflow runs for the current analysis.
+ *
+ * Dependency-bearing: the database `Pool` is captured by the factory
+ * (see the harness-durable-runtime spec). The analysis id is read from the request-scoped `Session`,
+ * not an ambient request context.
+ *
+ * Results are pull-only via this tool — the workflow does NOT write to the
+ * conversation thread on completion. The retired `run-result-writer` push
+ * payload (run status, step summaries, run synthesis, artifact paths) is
+ * surfaced here on demand: the run row + step `summaryPath` references +
+ * the `synthesisPath` for completed runs let the conversation agent
+ * `read_file` the artefacts it needs.
+ */
+import { ok } from "neverthrow";
+import { z } from "zod";
+import { queryRun, queryRunsByAnalysis, queryStepsByRun } from "../../state/index.js";
+import { scopeResource } from "../../auth/types.js";
+import { unwrapOrThrow } from "../../lib/result.js";
+import { defineTool } from "../define-tool.js";
+function formatRun(r, verbose) {
+    return {
+        runId: r.runId,
+        workflowName: r.workflowName,
+        status: r.status,
+        startedAt: r.startedAt,
+        completedAt: r.completedAt,
+        planId: r.planId,
+        synthesisPath: r.status === "completed" ? `runs/${r.runId}/synthesis.json` : null,
+        ...(verbose ? { error: r.error } : {}),
+    };
+}
+export function createInspectRunTool(pool) {
+    return defineTool({
+        id: "inspect_run",
+        description: "Inspect workflow runs for this analysis. " +
+            "Without a runId: lists all runs. " +
+            "With a runId: returns step-level details with paths to summary.md (and synthesis.json on completed runs). " +
+            "Default response is lightweight — pass includeDiagnostics:true to add error/duration/retry telemetry. " +
+            "Read summary.md or synthesis.json for findings, or use workspace search with type:summary or type:synthesis.",
+        inputSchema: z.object({
+            runId: z.string().optional().describe("Specific run to inspect. Omit to list all runs."),
+            includeDiagnostics: z
+                .boolean()
+                .optional()
+                .describe("Include failure/retry telemetry: run.error and step.{durationMs,error,attempts,lastErrorClass,finishReason,hitMaxSteps}. Default false."),
+        }),
+        execute: async (input, ctx) => {
+            const resourceId = scopeResource(ctx.session.scope).resourceId;
+            const verbose = input.includeDiagnostics === true;
+            if (!input.runId) {
+                const runs = unwrapOrThrow(await queryRunsByAnalysis(pool, resourceId));
+                if (runs.length === 0) {
+                    return ok({ message: "No runs found for this analysis." });
+                }
+                return ok({ runs: runs.map((r) => formatRun(r, verbose)) });
+            }
+            const run = unwrapOrThrow(await queryRun(pool, input.runId));
+            if (!run || run.analysisId !== resourceId) {
+                return ok({ message: `Run ${input.runId} not found.` });
+            }
+            const stepRows = unwrapOrThrow(await queryStepsByRun(pool, input.runId));
+            const steps = stepRows.map((s) => ({
+                stepId: s.stepId,
+                agentId: s.agentId,
+                wave: s.wave,
+                status: s.status,
+                // Seeded rows exist before a step ever runs; a summary path for one
+                // would point the agent at a file that cannot exist yet (or ever).
+                ...(s.status === "pending" || s.status === "skipped" ? {} : { summaryPath: `runs/${input.runId}/${s.stepId}/output/summary.md` }),
+                ...(verbose
+                    ? {
+                        durationMs: s.durationMs,
+                        error: s.error,
+                        attempts: s.attempts,
+                        lastErrorClass: s.lastErrorClass,
+                        finishReason: s.finishReason,
+                        hitMaxSteps: s.hitMaxSteps,
+                    }
+                    : {}),
+            }));
+            return ok({ run: formatRun(run, verbose), steps });
+        },
+    });
+}

package/dist/tools/research/literature-reviewer.d.ts

@@ -0,0 +1,29 @@
+/**
+ * literatureReviewer — a sub-agent packaged as a loop-driving tool.
+ *
+ * The conversation agent delegates batch literature/biology research by
+ * calling this tool. `execute` derives a child `Session` (`forSubAgent`)
+ * and runs `runAgent` over a focused literature-reviewer agent: a research
+ * brief in, a structured evidence report out. The child's transcript is
+ * ephemeral — it lives only for this call and is never persisted (see the harness-thread-store spec).
+ *
+ * This is the whole of sub-agent delegation in the harness. There is no
+ * `agents: {}` config, no `messageFilter`, no `stripParentToolParts`: the
+ * child cannot see the parent's tool history because it is simply handed
+ * none — only the brief. The child loop uses `passthroughStep` because the
+ * entire tool call is one step in the parent loop (PR #3 caches it whole,
+ * so the child never replays).
+ */
+import { type ChatProvider } from "../../providers/types.js";
+import { type Tool } from "../define-tool.js";
+import { type BioToolKeys } from "../bio/keys.js";
+export interface LiteratureReviewerDeps {
+    /** The LLM seam the child loop runs on. */
+    readonly provider: ChatProvider;
+    /** Model id — provenance / metric label; the provider owns the wire model. */
+    readonly model: string;
+    /** API keys for the bio/chem data sources the reviewer searches. */
+    readonly bioKeys: BioToolKeys;
+}
+/** Build the `literature_reviewer` delegation tool bound to its provider. */
+export declare function createLiteratureReviewerTool(deps: LiteratureReviewerDeps): Tool;