@inflexa-ai/harness 0.46.0 → 0.47.0

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." });
+        },
+    });
+}

package/dist/tools/script/codemode-worker.d.ts

@@ -0,0 +1,5 @@
+/**
+ * The entry of the worker thread of `run_script`. An embedder that bundles the harness, for example a Bun single-file
+ * binary, adds this module as an entry of its build, and gives its embedded path as `ScriptRuntime.workerUrl`.
+ */
+import "@earendil-works/pi-codemode/worker";

package/dist/tools/script/codemode-worker.js

@@ -0,0 +1,5 @@
+/**
+ * The entry of the worker thread of `run_script`. An embedder that bundles the harness, for example a Bun single-file
+ * binary, adds this module as an entry of its build, and gives its embedded path as `ScriptRuntime.workerUrl`.
+ */
+import "@earendil-works/pi-codemode/worker";

package/dist/tools/script/file-tools.d.ts

@@ -0,0 +1,100 @@
+/**
+ * The file tools of a script: `read_table`, `read_pdf`, `write_derived`, `render_chart`, and `export_pdf`.
+ *
+ * The VM of `run_script` has no file system. These tools are its only reach into the workspace, thus each one is
+ * the boundary. `read_table` reads through the read seam of the workspace, which confines a path to the analysis
+ * of the call and refuses a symbolic link. `write_derived` and `render_chart` write only into the `derived/`
+ * directory of the scratch of the session.
+ *
+ * A table read holds at most 16 MiB, and the parse runs on the host. A larger table, or a format with no parser
+ * here, is work for an analysis run, and the refusal says so.
+ *
+ * Each tool gives the files that it read or wrote as its call record. `run_script` collects the records of the
+ * calls of one script, thus the provenance of the script chains each derived file to the tables that it read.
+ */
+import { type Result } from "neverthrow";
+import { z } from "zod";
+import type { AgentSession } from "../../auth/types.js";
+import { type Row } from "../../report-model/production-resolver.js";
+import type { WorkspaceReadLineage } from "../../provenance/workspace-reads.js";
+import type { WorkspaceFilesystem } from "../../workspace/filesystem.js";
+import { type ResolveWorkspaceRoot } from "../../workspace/paths.js";
+import { type Tool, type WithToolCallRecord } from "../define-tool.js";
+import type { ScratchFile, ScriptRead, ScriptScratch } from "./scratch.js";
+/** The cap of one table read. It matches the cap of the report path, which reads with the same parsers. */
+export declare const TABLE_READ_CAP_BYTES: number;
+/** What one call of a file tool did to files. `run_script` reads it from the call record of a nested call. */
+export type ScriptFileEffect = {
+    readonly reads?: readonly ScriptRead[];
+    readonly writes?: readonly ScratchFile[];
+};
+export declare const ScriptFileEffectSchema: z.ZodObject<{
+    reads: z.ZodOptional<z.ZodArray<z.ZodObject<{
+        path: z.ZodString;
+        hash: z.ZodString;
+    }, z.core.$strip>>>;
+    writes: z.ZodOptional<z.ZodArray<z.ZodObject<{
+        path: z.ZodString;
+        hash: z.ZodString;
+        size: z.ZodNumber;
+    }, z.core.$strip>>>;
+}, z.core.$strip>;
+export type ScriptFileToolsDeps = {
+    readonly workspaceFs: WorkspaceFilesystem;
+    readonly resolveWorkspaceRoot: ResolveWorkspaceRoot;
+    readonly scratch: ScriptScratch;
+};
+/** The rows of one table, the bytes that they came from, and the columns that they keep. */
+export type TableRows = {
+    readonly content: Buffer;
+    readonly columns: string[];
+    readonly rows: Row[];
+};
+/**
+ * Read one table through the read seam, parse it on the host, and keep the named columns. A refusal is the line
+ * that the script reads. `tooLarge` names where a table over the cap goes instead.
+ */
+export declare function readTableRows(args: {
+    readonly workspaceFs: WorkspaceFilesystem;
+    readonly session: AgentSession;
+    readonly path: string;
+    readonly columns: readonly string[] | undefined;
+    readonly tooLarge: string;
+}): Promise<Result<TableRows, string>>;
+export declare const ReadTableOutputSchema: z.ZodObject<{
+    path: z.ZodString;
+    columns: z.ZodReadonly<z.ZodArray<z.ZodString>>;
+    rowCount: z.ZodNumber;
+    rows: z.ZodReadonly<z.ZodArray<z.ZodRecord<z.ZodString, z.ZodUnion<readonly [z.ZodString, z.ZodNumber]>>>>;
+}, z.core.$strip>;
+declare const readPdfInput: z.ZodObject<{
+    path: z.ZodString;
+    firstPage: z.ZodOptional<z.ZodNumber>;
+    lastPage: z.ZodOptional<z.ZodNumber>;
+}, z.core.$strip>;
+declare const ReadPdfOutputSchema: z.ZodObject<{
+    path: z.ZodString;
+    totalPages: z.ZodNumber;
+    pages: z.ZodReadonly<z.ZodArray<z.ZodObject<{
+        page: z.ZodNumber;
+        text: z.ZodString;
+    }, z.core.$strip>>>;
+}, z.core.$strip>;
+type ReadPdfOutput = WithToolCallRecord<z.infer<typeof ReadPdfOutputSchema>, ScriptFileEffect>;
+/** `lineage` records each read in the lineage of a step. */
+export declare function createReadPdfTool(deps: Pick<ScriptFileToolsDeps, "workspaceFs" | "resolveWorkspaceRoot"> & {
+    readonly lineage?: WorkspaceReadLineage;
+}): Tool<z.infer<typeof readPdfInput>, ReadPdfOutput>;
+export type Cell = string | number | boolean | null;
+/** The text of `rows` in the format that the extension of `name` names, or `undefined` for another extension. */
+export declare function rowsText(name: string, rows: readonly Record<string, Cell>[]): string | undefined;
+/** What the document tools of a script need. `imageScope` limits the images of a PDF to one directory of a session. */
+export type DocumentToolsDeps = ScriptFileToolsDeps & {
+    readonly imageScope?: (session: AgentSession) => string | undefined;
+};
+export declare function createScriptFileTools(deps: ScriptFileToolsDeps): Tool[];
+/** The script tools that read a table and a PDF of the workspace, and write nothing. */
+export declare function createReadScriptTools(deps: Pick<ScriptFileToolsDeps, "workspaceFs" | "resolveWorkspaceRoot">): Tool[];
+/** The tools that make a document in a script: a chart as an SVG file, and a PDF from markdown. */
+export declare function createDocumentTools(deps: DocumentToolsDeps): Tool[];
+export {};