@inflexa-ai/harness 0.46.2 → 0.48.0

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

@@ -22,6 +22,8 @@
  * last accepted plan, else the last clarification, else the first blocker —
  * and persists an accepted plan under an id that a rerun of the call gives again.
  */
+import { createReadScriptTools } from "../script/file-tools.js";
+import { createReadSurfaceTools } from "../workspace/read-surface.js";
 import { errorMessageOf } from "../../lib/thrown.js";
 import { textOf } from "../../lib/unknown-text.js";
 import { createHash } from "node:crypto";
@@ -51,6 +53,7 @@ import { createSearchSemanticScholarTool } from "./search-semantic-scholar.js";
 import { DATA_PROFILE_ORIENTATION_MAX_CHARS, buildDataProfileOrientation } from "../../app/data-profile-orientation.js";
 import { DEFAULT_SANDBOX_MAX_STEPS } from "../../config/resource-limits.js";
 import { plannerPrompt } from "../../prompts/planner.js";
+import { planCardOf } from "../../memory/card-builders.js";
 import { hydratePlanSteps, PlannerPlanSchema } from "../../schemas/plan-schemas.js";
 import { validatePlan } from "../../schemas/validate-plan.js";
 import { AnalysisPlanSchema } from "../../schemas/workflow-state.js";
@@ -169,10 +172,9 @@ function traceOf(steps) {
     return { submitAttempts, rejectedAttempts, rejections };
 }
 // ── 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);
+/** The planner system prompt is deterministic for the process: the catalog is fixed at load. */
+export function plannerInstructions() {
+    return plannerPrompt(formatAgentCatalog());
 }
 const ValidationIssueSchema = z.object({ path: z.string(), code: z.enum(["schema", "semantic"]), message: z.string(), hint: z.string().optional() });
 const SubmitPlanOutputSchema = z.discriminatedUnion("accepted", [
@@ -226,7 +228,7 @@ function selectedOutcomeOf(steps) {
  * 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) {
+export function formatPriorPlan(parentPlanId, plan) {
     const parsed = AnalysisPlanSchema.safeParse(plan);
     if (!parsed.success)
         return null;
@@ -243,10 +245,9 @@ function formatPriorPlan(parentPlanId, plan) {
         "**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.",
+        "The user is revising this plan, not asking for a new one. The changes are in `## User Constraints`. " +
+            "Each step keeps its id, its agent, and its order, also a step that the user asked to change: apply the change to that step. " +
+            "Thus `depends_on` and the stored artifacts survive. Give a new id to new work only.",
     ].join("\n");
 }
 /**
@@ -305,7 +306,7 @@ const NO_FACTS_GUIDANCE = "Plan from the research question alone, do not invent
  *
  * Pure — the same grounding renders the same string.
  */
-function renderDataContext(grounding, analysisId) {
+export function renderDataContext(grounding, analysisId) {
     switch (grounding.kind) {
         case "absent":
             return "";
@@ -356,7 +357,7 @@ async function persistPlan(plan, ctx, pool, logger) {
         unwrapOrThrow(await upsertPlan(pool, {
             planId,
             analysisId: ctx.analysisId,
-            plan: hydratePlanSteps(plan),
+            plan: { ...hydratePlanSteps(plan), request: ctx.request },
             parentPlanId: ctx.parentPlanId,
         }));
         return { ok: true, planId };
@@ -523,7 +524,7 @@ function restoreSkeletonGrounding(candidate, memory) {
  * Full validation: Zod schema + semantic checks. The plan is valid only if
  * BOTH pass.
  */
-function fullyValidate(candidate, resourcePolicy) {
+function fullyValidate(candidate) {
     // The permissive arg schema of the planner tools accepts a string, thus the
     // loop-boundary repair never sees a plan that a model sent as a JSON-encoded
     // string. A small model does this on a large nested schema. Decode it here,
@@ -546,7 +547,7 @@ function fullyValidate(candidate, resourcePolicy) {
         created_at: parsed.data.created_at,
         omicsType: parsed.data.omicsType,
         omicsSubtype: parsed.data.omicsSubtype,
-    }, { perStepCeiling: resourcePolicy?.perStep });
+    });
     if (!semantic.valid) {
         return {
             valid: false,
@@ -559,11 +560,30 @@ function fullyValidate(candidate, resourcePolicy) {
     }
     return { valid: true, plan: parsed.data };
 }
+/** The planner agent over its search tools and its terminal tools. */
+export function plannerAgentOf(deps, searchTools, terminal) {
+    const readTools = deps.toolOutputStore ? [createReadToolOutputTool(deps.toolOutputStore)] : [];
+    return {
+        id: PLANNER_AGENT_ID,
+        systemPrompt: composeSystemPrompt(plannerInstructions()),
+        model: deps.conversation.model,
+        // The search tools come first, and the terminal tools come last. The order is the order of the prompt, and it
+        // is stable across every invocation, thus the cached request prefix holds.
+        tools: [...searchTools, ...createReadSurfaceTools(deps.workspace), ...readTools, ...terminal],
+        scriptTools: createReadScriptTools(deps.workspace),
+        scriptRuntime: deps.scriptRuntime,
+        maxIterations: PLANNER_MAX_ITERATIONS,
+    };
+}
+/** The terminal tools of a planner with no knowledge answer, for a consumer that runs the planner outside this tool. */
+export function plannerTerminalTools(logger) {
+    return buildInnerTools(logger, { steps: new Map(), claims: new Set() }).terminal;
+}
 /**
  * Build the planner's inner tools for one invocation. `memory` holds the last
  * `knowledge_recommend` answer of the run, which the loop folds after each round.
  */
-function buildInnerTools(resourcePolicy, logger, memory) {
+function buildInnerTools(logger, memory) {
     const submitPlanTool = defineTool({
         id: SUBMIT_PLAN_TOOL_ID,
         description: "Submit the plan. Checks the plan; on success returns {accepted: true, plan} " +
@@ -592,7 +612,7 @@ function buildInnerTools(resourcePolicy, logger, memory) {
                 logger.info("submit_plan restored the template of skeleton steps", { steps: restored });
             if (repaired.length > 0)
                 logger.info("submit_plan repaired the claim ids of plan steps", { claims: repaired });
-            const result = fullyValidate(candidate, resourcePolicy);
+            const result = fullyValidate(candidate);
             // An unknown claim rejects a plan that the schema accepts, beside the
             // schema issues when the schema rejects it, thus one attempt shows both.
             if (!result.valid || unknown.length > 0) {
@@ -644,7 +664,7 @@ function buildInnerTools(resourcePolicy, logger, memory) {
  * no outcome distinguishes. The record is what makes "the planner produced a plan
  * naming packages this install does not have" traceable to its cause.
  */
-function inventoryContent(label, result, logger) {
+export function inventoryContent(label, result, logger) {
     if (result.isErr()) {
         logger.warn("planner grounding inventory lookup failed", { inventory: label, error: result.error.error });
         return `## ${label}\n\nInventory lookup failed: ${result.error.error}`;
@@ -855,8 +875,28 @@ export function buildPlannerSearchTools(deps, hooks = {}) {
         }),
     ];
 }
+/**
+ * The seed of the planner: the prior plan when the call revises one, the data context, the two censuses, and then
+ * what the caller gave. Each block is optional where the call holds none.
+ */
+export function composePlannerSeed(parts) {
+    const { priorPlanBlock, dataContextBlock, groundingBlock, input } = parts;
+    return [
+        ...(priorPlanBlock ? [priorPlanBlock, ""] : []),
+        ...(dataContextBlock ? [dataContextBlock, ""] : []),
+        groundingBlock,
+        "",
+        "## Research Question",
+        input.researchQuestion,
+        ...(input.analystNotes ? ["", "## Analyst Notes (from the user — facts about the data the profile does not record)", input.analystNotes] : []),
+        ...(input.priorRuns ? ["", "## Prior Run Results", input.priorRuns] : []),
+        ...(input.userConstraints ? ["", "## User Constraints", input.userConstraints] : []),
+    ].join("\n");
+}
 const generatePlanInputSchema = z.object({
-    researchQuestion: z.string().describe("What the user wants to analyze — their goal and specific questions."),
+    researchQuestion: z
+        .string()
+        .describe("The request of the user, in the words of the user: the goal, the questions, and each deliverable that the user named, with its format. The plan stores it, and each step of the run reads it."),
     analystNotes: z
         .string()
         .optional()
@@ -983,17 +1023,7 @@ export function createGeneratePlanTool(deps, registerSubAgent) {
             const refsBlock = inventoryContent("Available Reference Data", refsResult, logger);
             const packagesBlock = inventoryContent("Available Packages", packagesResult, logger);
             const groundingBlock = [refsBlock, packagesBlock].join("\n\n");
-            const prompt = [
-                ...(priorPlanBlock ? [priorPlanBlock, ""] : []),
-                ...(dataContextBlock ? [dataContextBlock, ""] : []),
-                groundingBlock,
-                "",
-                "## Research Question",
-                input.researchQuestion,
-                ...(input.analystNotes ? ["", "## Analyst Notes (from the user — facts about the data the profile does not record)", input.analystNotes] : []),
-                ...(input.priorRuns ? ["", "## Prior Run Results", input.priorRuns] : []),
-                ...(input.userConstraints ? ["", "## User Constraints", input.userConstraints] : []),
-            ].join("\n");
+            const prompt = composePlannerSeed({ priorPlanBlock, dataContextBlock, groundingBlock, input });
             return {
                 prompt,
                 grounding: grounding.kind,
@@ -1037,13 +1067,14 @@ export function createGeneratePlanTool(deps, registerSubAgent) {
             analysisId,
             parentPlanId: input.parentPlanId ?? null,
             invocationId: ctx.invocationId,
+            request: input.researchQuestion,
         };
         // The last recommend answer of this invocation, thus `submit_plan`
         // stamps the snapshot digest, restores a template the model dropped,
         // and repairs or refuses a claim id the answer did not return. The loop
         // folds each answer after its round, on the first run and on a replay.
         const memory = { steps: new Map(), claims: new Set() };
-        const innerTools = buildInnerTools(deps.resourcePolicy, logger, memory);
+        const innerTools = buildInnerTools(logger, memory);
         // Built here rather than at construction: a `describeCall` hook reads no
         // dep, thus the tool must stay constructible from an empty bag. The tool
         // definitions are identical across invocations, thus the request prefix
@@ -1051,17 +1082,7 @@ export function createGeneratePlanTool(deps, registerSubAgent) {
         const searchTools = buildPlannerSearchTools(deps, {
             onRecommend: (answer) => rememberAnswer(memory, answer),
         });
-        const readTools = deps.toolOutputStore ? [createReadToolOutputTool(deps.toolOutputStore)] : [];
-        const planner = {
-            id: PLANNER_AGENT_ID,
-            systemPrompt: composeSystemPrompt(plannerInstructions(deps.resourcePolicy)),
-            model: deps.conversation.model,
-            // The search tools come first, and the terminal tools come last.
-            // The order is the order of the prompt, and it is stable across
-            // every invocation, thus the cached request prefix holds.
-            tools: [...searchTools, ...readTools, ...innerTools.terminal],
-            maxIterations: PLANNER_MAX_ITERATIONS,
-        };
+        const planner = plannerAgentOf(deps, searchTools, innerTools.terminal);
         // Merge the outer abort signal with a wall-clock timeout — either
         // cancels the planner promptly.
         const signal = AbortSignal.any([ctx.signal, AbortSignal.timeout(planTimeoutMs)]);
@@ -1155,13 +1176,23 @@ export function createGeneratePlanTool(deps, registerSubAgent) {
             "record more faithfully than the record itself. Pass only what the profile cannot hold: the research " +
             "question, facts the user told you (analystNotes), prior run results, and their constraints. " +
             "The planner is a multi-step sub-agent, thus a call can take many minutes. " +
-            "The result carries an `event`: `plan_complete` with {planId, plan} — the plan is saved and ready for show_plan and " +
-            "execute_analysis plan mode, and this call neither shows nor runs it; `clarification_needed` with {question, questionContext?} " +
+            "The result carries an `event`: `plan_complete` with {planId, plan} — the plan is saved, the call shows its plan card to the user, " +
+            "and it does not run it (execute_analysis plan mode does, after the approval); `clarification_needed` with {question, questionContext?} " +
             "when the planner is missing a fact it cannot infer; or `error` with {error} when no plan was saved (the planner reported " +
             "a blocker, the save failed, the call timed out or was cancelled, or parentPlanId is not a plan of this analysis).",
         inputSchema: generatePlanInputSchema,
         describeCall: ({ researchQuestion }) => researchQuestion,
         startsWorkflow: true,
-        execute: async (input, ctx) => ok(await plan(input, ctx)),
+        execute: async (input, ctx) => {
+            const output = await plan(input, ctx);
+            // The card comes from the result of the planner, with no read of the store, thus a replay of the body
+            // gives the same card under the same id, and a reader keeps one card.
+            if (output.event === "plan_complete" && output.planId !== undefined && output.plan !== undefined) {
+                const card = planCardOf({ planId: output.planId, plan: hydratePlanSteps(output.plan), parentPlanId: input.parentPlanId ?? null });
+                if (card !== null)
+                    await ctx.emit({ type: "data-plan", source: ctx.session.provenance, data: card });
+            }
+            return ok(output);
+        },
     });
 }

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

@@ -1,14 +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.
+ * analogical-reasoner sub-agent, the lookups of the run synthesizer,
+ * 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 "./inspect-data-profile.js";
-export * from "./literature-reviewer.js";
+export * from "./synthesis-lookups.js";
 export * from "./generate-analogy-report.js";
 export * from "./context7-docs.js";
 export * from "./search-semantic-scholar.js";

package/dist/tools/research/index.js

@@ -1,14 +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.
+ * analogical-reasoner sub-agent, the lookups of the run synthesizer,
+ * 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 "./inspect-data-profile.js";
-export * from "./literature-reviewer.js";
+export * from "./synthesis-lookups.js";
 export * from "./generate-analogy-report.js";
 export * from "./context7-docs.js";
 export * from "./search-semantic-scholar.js";

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

@@ -69,7 +69,6 @@ type InspectRunOutput = {
     steps: FormattedStep[];
     elapsedMs?: number;
     wait?: WaitMetadata;
-    selfWaitPrevented?: boolean;
 };
 type InspectRunClock = {
     now(): number;

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

@@ -106,8 +106,7 @@ export function createInspectRunTool(pool, clock = systemClock) {
             "With a runId, returns the run, its steps, and an inspectionState: not_found; in_progress; paused (a step waits until the user resumes or stops the run, and pauses gives each cause); " +
             "or terminal (run.status completed, partial, failed, or canceled). " +
             "Output paths appear only on a terminal run: run.synthesisPath when synthesisStatus is produced, and the summaryPath of each step that ran. " +
-            "For a user-directed check, waitForTerminalSeconds can wait once for 1-30 seconds; if the cutoff returns in_progress, stop polling for that turn. " +
-            "A wait on the run that the caller itself runs inside returns at once with selfWaitPrevented. " +
+            "For a user-directed check, waitForTerminalSeconds can wait once for 1-30 seconds; if the cutoff returns in_progress, stop polling for that turn and tell the user that the run still runs. " +
             "Default response is lightweight — pass includeDiagnostics:true to add error/duration/retry telemetry.",
         inputSchema,
         // The two calls do different work: one inspects a named run, the other
@@ -139,12 +138,11 @@ export function createInspectRunTool(pool, clock = systemClock) {
                     wait: waitSeconds === undefined ? undefined : { requestedSeconds: waitSeconds, cutoffReached: false },
                 });
             }
-            const selfWait = waitSeconds !== undefined && ctx.session.runFrame?.runId === input.runId;
             const runId = input.runId;
             const pausesOf = async (status) => status === "running" ? unwrapOrThrow(await queryPausesOfWork(pool, resourceId, runId)) : [];
             let pauses = await pausesOf(run.status);
             let cutoffReached = false;
-            if (waitSeconds !== undefined && run.status === "running" && pauses.length === 0 && !selfWait) {
+            if (waitSeconds !== undefined && run.status === "running" && pauses.length === 0) {
                 const deadline = clock.now() + waitSeconds * 1_000;
                 while (run.status === "running" && pauses.length === 0) {
                     const remaining = deadline - clock.now();
@@ -180,11 +178,9 @@ export function createInspectRunTool(pool, clock = systemClock) {
                 });
             }
             if (run.status === "running") {
-                const message = selfWait
-                    ? "This run is still in progress. Results are not ready, and the enclosing workflow cannot finish while its current step waits for itself."
-                    : cutoffReached
-                        ? "This run is still in progress after the requested wait cutoff. Results are not ready; stop polling for this turn."
-                        : "This run is in progress. Results are not ready.";
+                const message = cutoffReached
+                    ? "This run is still in progress after the requested wait cutoff. Results are not ready; stop polling for this turn."
+                    : "This run is in progress. Results are not ready.";
                 return ok({
                     inspectionState: "in_progress",
                     message,
@@ -192,7 +188,6 @@ export function createInspectRunTool(pool, clock = systemClock) {
                     steps,
                     elapsedMs: Math.max(0, clock.now() - Date.parse(run.startedAt)),
                     ...wait,
-                    selfWaitPrevented: selfWait ? true : undefined,
                 });
             }
             return ok({

package/dist/tools/research/search-arxiv.js

@@ -4,6 +4,20 @@ import { z } from "zod";
 import { createArxivSource } from "../../literature/sources/arxiv.js";
 import { defineTool } from "../define-tool.js";
 export { parseArxivAtom } from "../../literature/sources/arxiv.js";
+const SearchArxivOutputSchema = z.object({
+    success: z.boolean(),
+    error: z.string().optional().describe("Present when success is false: why the search failed."),
+    papers: z.array(z.object({
+        id: z.string(),
+        title: z.string(),
+        abstract: z.string(),
+        authors: z.array(z.string()),
+        published: z.string(),
+        categories: z.array(z.string()),
+        url: z.string(),
+        pdfUrl: z.string().optional(),
+    })),
+});
 const source = createArxivSource({ maxRetries: 3, retryDelayMs: 1_000, timeoutMs: 90_000 });
 export const searchArxivTool = defineTool({
     id: "search_arxiv",
@@ -15,6 +29,7 @@ export const searchArxivTool = defineTool({
         "('2301.00001') also matches as free text.\n" +
         "ABSENCE IS NORMAL: an empty papers array means arXiv holds nothing for the query, and `success: false` with an `error` string means the service " +
         "could not be reached. Report either one and continue, do not retry unchanged.",
+    outputSchema: SearchArxivOutputSchema,
     inputSchema: z.object({
         query: z.string().describe('Free-text query. Example: "adaptive control feedback stabilization".'),
         categories: z

package/dist/tools/research/search-github-repos.js

@@ -16,6 +16,18 @@ import { apiFetchValidated, describeApiError } from "../lib/api-utils.js";
 import { parseUnknownRecord } from "../../lib/unknown-containers.js";
 import { isUnknownArray } from "../../lib/unknown-array.js";
 const BASE_URL = "https://api.github.com/search/repositories";
+const SearchGithubReposOutputSchema = z.object({
+    success: z.boolean(),
+    error: z.string().optional().describe("Present when success is false: why the search failed."),
+    repos: z.array(z.object({
+        url: z.string(),
+        fullName: z.string(),
+        description: z.string().optional(),
+        stars: z.number(),
+        language: z.string().optional(),
+        lastUpdated: z.string().optional(),
+    })),
+});
 // Raw GitHub search wire shape, validated at the fetch boundary. Every field is
 // optional — `parseGithubReposResponse` already filters out items missing the
 // fields it needs, so an over-strict schema would drop otherwise-usable pages.
@@ -73,6 +85,7 @@ export function createSearchGithubReposTool(deps) {
             "and `success: false` with an `error` string means GitHub could not be " +
             "reached or refused the request (the low unauthenticated rate limit " +
             "lands here). Report either one and continue, do not retry unchanged.",
+        outputSchema: SearchGithubReposOutputSchema,
         inputSchema: SearchGithubReposInputSchema,
         describeCall: "none",
         execute: async ({ query, language, limit }) => {

package/dist/tools/research/search-semantic-scholar.js

@@ -4,6 +4,21 @@ import { z } from "zod";
 import { createSemanticScholarSource } from "../../literature/sources/semantic-scholar.js";
 import { defineTool } from "../define-tool.js";
 export { parseSemanticScholarResponse } from "../../literature/sources/semantic-scholar.js";
+const SearchSemanticScholarOutputSchema = z.object({
+    success: z.boolean(),
+    error: z.string().optional().describe("Present when success is false: why the search failed."),
+    papers: z.array(z.object({
+        id: z.string(),
+        title: z.string(),
+        abstract: z.string().optional(),
+        year: z.number().optional(),
+        venue: z.string().optional(),
+        citationCount: z.number().optional(),
+        url: z.string().optional(),
+        authors: z.array(z.string()),
+        externalIds: z.record(z.string(), z.string()).optional().describe("For example DOI, ArXiv, PubMed, CorpusId."),
+    })),
+});
 export function createSearchSemanticScholarTool(options = {}) {
     const source = createSemanticScholarSource({
         maxRetries: 3,
@@ -23,6 +38,7 @@ export function createSearchSemanticScholarTool(options = {}) {
             "back for a citation.\n" +
             "ABSENCE IS NORMAL: an empty papers array means the corpus holds nothing for the query, and `success: false` with an `error` string means the " +
             "service could not be reached (its unkeyed rate limit lands here). Report either one and continue, do not retry unchanged.",
+        outputSchema: SearchSemanticScholarOutputSchema,
         inputSchema: z.object({
             query: z
                 .string()

package/dist/tools/research/synthesis-lookups.d.ts

@@ -0,0 +1,21 @@
+/**
+ * The lookups of the run synthesizer: the gene, protein, annotation,
+ * interaction, PubMed, citation, drug-gene, and preclinical-profile tools.
+ *
+ * The synthesizer calls them directly, thus each lookup result, and each PMID
+ * that the synthesis cites, is in the transcript of the synthesizer, where
+ * `submit_synthesis` can check it.
+ */
+import type { CitationResolver } from "../../citations/types.js";
+import type { Logger } from "../../lib/logger.js";
+import { type BioToolKeys } from "../bio/keys.js";
+import type { Tool } from "../define-tool.js";
+export type SynthesisLookupDeps = {
+    /** API keys for the bio/chem data sources of the lookups. */
+    readonly bioKeys: BioToolKeys;
+    /** Shared bibliographic verification service; all agent surfaces share its pacing/cache. */
+    readonly citationResolver: CitationResolver;
+    /** Operational logging; omitted falls back to no-op. */
+    readonly logger?: Logger;
+};
+export declare function createSynthesisLookupTools(deps: SynthesisLookupDeps): readonly Tool[];

package/dist/tools/research/synthesis-lookups.js

@@ -0,0 +1,29 @@
+/**
+ * The lookups of the run synthesizer: the gene, protein, annotation,
+ * interaction, PubMed, citation, drug-gene, and preclinical-profile tools.
+ *
+ * The synthesizer calls them directly, thus each lookup result, and each PMID
+ * that the synthesis cites, is in the transcript of the synthesizer, where
+ * `submit_synthesis` can check it.
+ */
+import { genePreclinicalProfileTool } from "../bio/gene-preclinical-profile.js";
+import { createChemDbTools, createNcbiTools } from "../bio/keys.js";
+import { lookupAnnotationTool } from "../bio/lookup-annotation.js";
+import { searchGeneTool } from "../bio/search-gene.js";
+import { searchInteractionsTool } from "../bio/search-interactions.js";
+import { searchProteinTool } from "../bio/search-protein.js";
+import { createResolveCitationTool } from "./resolve-citation.js";
+export function createSynthesisLookupTools(deps) {
+    const ncbi = createNcbiTools(deps.bioKeys);
+    const chemDb = createChemDbTools(deps.bioKeys, { logger: deps.logger });
+    return [
+        searchGeneTool,
+        searchProteinTool,
+        lookupAnnotationTool,
+        searchInteractionsTool,
+        ncbi.pubmed,
+        createResolveCitationTool(deps.citationResolver),
+        chemDb.drugGeneInteractions,
+        genePreclinicalProfileTool,
+    ];
+}

package/dist/tools/research/web-fetch.d.ts

@@ -3,7 +3,7 @@
  *
  * One URL in, extracted text out: HTML becomes Markdown (Readability over a
  * `linkedom` DOM, then Turndown, with the body text as the fallback), a PDF
- * becomes the text of its first 100 pages through `pdf-parse`, and a text or
+ * becomes the text of its first 100 pages through `unpdf`, and a text or
  * JSON body passes through. A bad scheme, an internal address, an HTTP error, an
  * oversized body, a redirect chain past the limit, and a body the tool cannot
  * extract are all normal results on the ok channel — never a failure of the

package/dist/tools/research/web-fetch.js

@@ -3,7 +3,7 @@
  *
  * One URL in, extracted text out: HTML becomes Markdown (Readability over a
  * `linkedom` DOM, then Turndown, with the body text as the fallback), a PDF
- * becomes the text of its first 100 pages through `pdf-parse`, and a text or
+ * becomes the text of its first 100 pages through `unpdf`, and a text or
  * JSON body passes through. A bad scheme, an internal address, an HTTP error, an
  * oversized body, a redirect chain past the limit, and a body the tool cannot
  * extract are all normal results on the ok channel — never a failure of the
@@ -420,27 +420,29 @@ function htmlExtractionOf(body) {
         }
     }
 }
-let pdfParseModule;
+let pdfTextModule;
 async function extractBody(contentType, body) {
     if (contentType === "text/html" || contentType === "application/xhtml+xml") {
         return htmlExtractionOf(body);
     }
     if (contentType === "application/pdf") {
-        // `pdf-parse` makes `os.availableParallelism()` return `undefined` process-wide under Bun when its module loads,
-        // so the public barrel must never import it statically (inflexa-ai/inflexa#701). The first PDF loads it once.
-        pdfParseModule ??= await import("pdf-parse");
-        const parser = new pdfParseModule.PDFParse({ data: body });
+        // PDF.js is a large module, thus the first PDF loads it, and a host that fetches no PDF never pays for it.
+        pdfTextModule ??= await import("../../lib/pdf-text.js");
         try {
-            const result = await parser.getText({ first: PDF_PAGE_CAP });
-            const pdfCut = result.total > result.pages.length ? { totalPages: result.total, pagesRead: result.pages.length } : undefined;
-            return { kind: "text", text: result.text.trim(), pdfCut };
+            const result = await pdfTextModule.readPdfText(body, { first: 1, last: PDF_PAGE_CAP });
+            const pdfCut = result.totalPages > result.pages.length ? { totalPages: result.totalPages, pagesRead: result.pages.length } : undefined;
+            return {
+                kind: "text",
+                text: result.pages
+                    .map((page) => page.text)
+                    .join("\n\n")
+                    .trim(),
+                pdfCut,
+            };
         }
         catch (error) {
             return { kind: "unextractable", detail: `the PDF parser failed: ${errorMessageOf(error) ?? textOf(error)}` };
         }
-        finally {
-            await parser.destroy();
-        }
     }
     if (contentType.startsWith("text/") || contentType === "application/json" || contentType.endsWith("+json")) {
         return { kind: "text", text: body.toString("utf8") };

package/dist/tools/sandbox/lease-tools.d.ts

@@ -0,0 +1,32 @@
+/**
+ * `acquire_sandbox` and `release_sandbox` (sandbox-leases spec): the agent holds its sandbox through a lease.
+ *
+ * Each tool gives the size, and nothing else. The bound lease carries the key (the id of the workflow of the agent),
+ * the session, and the spawn settings of the step, and the sandbox module owns the admission, the spawn, and the
+ * teardown. `acquire_sandbox` blocks until the machine is ready, also while the lease waits in the queue.
+ */
+import { z } from "zod";
+import type { BoundLease } from "../../sandbox/leases.js";
+import { type Tool } from "../define-tool.js";
+export declare const ACQUIRE_SANDBOX_TOOL_ID = "acquire_sandbox";
+export declare const RELEASE_SANDBOX_TOOL_ID = "release_sandbox";
+declare const AcquireSandboxInputSchema: z.ZodObject<{
+    cpu: z.ZodNumber;
+    memoryGb: z.ZodNumber;
+    gpuCount: z.ZodOptional<z.ZodNumber>;
+}, z.core.$strip>;
+type AcquireSandboxResult = {
+    readonly status: "granted";
+    readonly cpu: number;
+    readonly memoryGb: number;
+    readonly gpuCount: number;
+    readonly message: string;
+};
+declare const ReleaseSandboxInputSchema: z.ZodObject<{}, z.core.$strip>;
+type ReleaseSandboxResult = {
+    readonly status: "released";
+    readonly message: string;
+};
+export declare function createAcquireSandboxTool(lease: BoundLease): Tool<z.infer<typeof AcquireSandboxInputSchema>, AcquireSandboxResult>;
+export declare function createReleaseSandboxTool(lease: BoundLease): Tool<z.infer<typeof ReleaseSandboxInputSchema>, ReleaseSandboxResult>;
+export {};

package/dist/tools/sandbox/lease-tools.js

@@ -0,0 +1,60 @@
+/**
+ * `acquire_sandbox` and `release_sandbox` (sandbox-leases spec): the agent holds its sandbox through a lease.
+ *
+ * Each tool gives the size, and nothing else. The bound lease carries the key (the id of the workflow of the agent),
+ * the session, and the spawn settings of the step, and the sandbox module owns the admission, the spawn, and the
+ * teardown. `acquire_sandbox` blocks until the machine is ready, also while the lease waits in the queue.
+ */
+import { err, ok } from "neverthrow";
+import { z } from "zod";
+import { defineTool } from "../define-tool.js";
+export const ACQUIRE_SANDBOX_TOOL_ID = "acquire_sandbox";
+export const RELEASE_SANDBOX_TOOL_ID = "release_sandbox";
+const AcquireSandboxInputSchema = z.object({
+    cpu: z.number().positive().describe("CPU cores of the sandbox. A fraction is permitted, and the grant can be smaller than the request."),
+    memoryGb: z.number().positive().describe("Memory of the sandbox in GB. A command that uses more memory gets an out-of-memory kill."),
+    gpuCount: z.number().int().nonnegative().optional().describe("GPUs of the sandbox. Omit for none."),
+});
+const ReleaseSandboxInputSchema = z.object({});
+export function createAcquireSandboxTool(lease) {
+    return defineTool({
+        id: ACQUIRE_SANDBOX_TOOL_ID,
+        description: "Get a sandbox of the given size for `execute_command`, and wait until it is ready. The call can wait for free " +
+            "capacity. The result gives the granted size, which can be smaller than the request. A call with a different " +
+            "size replaces your sandbox: the files of your working directory stay, and the next command runs on the new " +
+            "size. Your files and your outputs live in the workspace, not in the sandbox.",
+        inputSchema: AcquireSandboxInputSchema,
+        describeCall: ({ cpu, memoryGb }) => `Waiting for a sandbox (${cpu} CPU, ${memoryGb} GB)`,
+        execute: async ({ cpu, memoryGb, gpuCount }) => {
+            const size = gpuCount === undefined || gpuCount === 0 ? { cpu, memoryGb } : { cpu, memoryGb, gpu: { count: gpuCount } };
+            const outcome = await lease.acquire(size);
+            switch (outcome.kind) {
+                case "granted":
+                    return ok({
+                        status: "granted",
+                        cpu: outcome.size.cpu,
+                        memoryGb: outcome.size.memoryGb,
+                        gpuCount: outcome.size.gpu?.count ?? 0,
+                        message: "The sandbox is ready.",
+                    });
+                case "refused":
+                    return err({ error: `The host refused the sandbox: ${outcome.reason}.`, retryable: false });
+                case "failed":
+                    return err({ error: `The sandbox did not start: ${outcome.detail}`, retryable: true });
+            }
+        },
+    });
+}
+export function createReleaseSandboxTool(lease) {
+    return defineTool({
+        id: RELEASE_SANDBOX_TOOL_ID,
+        description: "Release your sandbox when your commands are done and you work only with files or research. The files stay. " +
+            "A later `execute_command` needs `acquire_sandbox` again.",
+        inputSchema: ReleaseSandboxInputSchema,
+        describeCall: () => "Releasing the sandbox",
+        execute: async () => {
+            await lease.release();
+            return ok({ status: "released", message: "The sandbox is released." });
+        },
+    });
+}