@inflexa-ai/harness 0.1.1

package/dist/tools/lib/report-preflight.d.ts

@@ -0,0 +1,39 @@
+/**
+ * Report pre-flight — deterministic asset staging for iterate-report.
+ *
+ * Runs before the report-builder agent starts. Resolves each declared
+ * source under the analysis root, enforces the 50MB cap, copies bytes
+ * into the preview's shared assets/ dir, and enriches the brief with
+ * inferred kind, size, CSV columns, head rows, and row count.
+ *
+ * The builder receives a complete brief and never has to discover or
+ * stage anything itself.
+ */
+export type AssetKind = "csv" | "tsv" | "image" | "json" | "other";
+export interface StagedAsset {
+    name: string;
+    path: string;
+    kind: AssetKind;
+    sizeBytes: number;
+    rowCount?: number;
+    columns?: string[];
+    headRows?: string[][];
+}
+export interface PreflightSource {
+    path: string;
+    as?: string;
+}
+export type PreflightResult = {
+    ok: true;
+    staged: StagedAsset[];
+} | {
+    ok: false;
+    reason: string;
+};
+export interface PreflightOptions {
+    sources: PreflightSource[];
+    analysisRoot: string;
+    assetsDirAbs: string;
+}
+export declare function stageReportAssets(opts: PreflightOptions): Promise<PreflightResult>;
+export declare function formatBytes(bytes: number): string;

package/dist/tools/lib/report-preflight.js

@@ -0,0 +1,283 @@
+/**
+ * Report pre-flight — deterministic asset staging for iterate-report.
+ *
+ * Runs before the report-builder agent starts. Resolves each declared
+ * source under the analysis root, enforces the 50MB cap, copies bytes
+ * into the preview's shared assets/ dir, and enriches the brief with
+ * inferred kind, size, CSV columns, head rows, and row count.
+ *
+ * The builder receives a complete brief and never has to discover or
+ * stage anything itself.
+ */
+import { copyFile, mkdir, open, realpath, stat } from "node:fs/promises";
+import { basename, extname, resolve, sep } from "node:path";
+const MAX_ASSET_BYTES = 50 * 1024 * 1024;
+const MAX_ASSET_LABEL = "50MB";
+const HEAD_BUF_BYTES = 64 * 1024;
+const HEAD_ROW_COUNT = 5;
+const COUNT_CHUNK_BYTES = 64 * 1024;
+// JSON enrichment parses the whole file to detect array-of-objects shape.
+// Cap below the 50MB asset limit so we don't synchronously parse huge files
+// just for metadata — large JSON gets staged but lands in the brief without
+// columns/rowCount, the same way a non-tabular JSON would.
+const JSON_ENRICH_MAX_BYTES = 5 * 1024 * 1024;
+export async function stageReportAssets(opts) {
+    await mkdir(opts.assetsDirAbs, { recursive: true });
+    // Canonicalize analysisRoot so containment checks work when the path
+    // traverses symlinks (e.g. macOS /var → /private/var).
+    const analysisRoot = await realpath(opts.analysisRoot);
+    // Dedupe by destination name. Identical (path, name) pairs collapse
+    // silently; conflicting names from different paths are an error.
+    const byName = new Map();
+    for (const src of opts.sources) {
+        const name = (src.as ?? basename(src.path)).trim();
+        if (!name) {
+            return { ok: false, reason: `source has no destination name: ${src.path}` };
+        }
+        const existing = byName.get(name);
+        if (existing && existing.path !== src.path) {
+            return {
+                ok: false,
+                reason: `duplicate asset name '${name}' from sources '${existing.path}' and '${src.path}' — use \`as\` to disambiguate`,
+            };
+        }
+        byName.set(name, src);
+    }
+    const staged = [];
+    for (const [name, src] of byName) {
+        const resolved = await resolveSource(src.path, analysisRoot);
+        if (!resolved.ok)
+            return resolved;
+        let st;
+        try {
+            st = await stat(resolved.path);
+        }
+        catch {
+            return { ok: false, reason: `source not found: ${src.path}` };
+        }
+        if (!st.isFile()) {
+            return { ok: false, reason: `source is not a regular file: ${src.path}` };
+        }
+        if (st.size > MAX_ASSET_BYTES) {
+            return {
+                ok: false,
+                reason: `source ${src.path} is ${formatBytes(st.size)} — exceeds ${MAX_ASSET_LABEL} cap`,
+            };
+        }
+        const dst = resolveDestination(name, opts.assetsDirAbs);
+        if (!dst.ok)
+            return dst;
+        await copyFile(resolved.path, dst.path);
+        const kind = inferKind(name);
+        const asset = {
+            name,
+            path: src.path,
+            kind,
+            sizeBytes: st.size,
+        };
+        if (kind === "csv" || kind === "tsv") {
+            const enriched = await enrichTabular(dst.path, kind === "tsv" ? "\t" : ",");
+            if (enriched.columns)
+                asset.columns = enriched.columns;
+            if (enriched.headRows)
+                asset.headRows = enriched.headRows;
+            if (enriched.rowCount !== undefined)
+                asset.rowCount = enriched.rowCount;
+        }
+        else if (kind === "json" && st.size <= JSON_ENRICH_MAX_BYTES) {
+            const enriched = await enrichJson(dst.path);
+            if (enriched.columns)
+                asset.columns = enriched.columns;
+            if (enriched.headRows)
+                asset.headRows = enriched.headRows;
+            if (enriched.rowCount !== undefined)
+                asset.rowCount = enriched.rowCount;
+        }
+        staged.push(asset);
+    }
+    return { ok: true, staged };
+}
+/**
+ * Resolves a source path under analysisRoot and canonicalizes through
+ * symlinks. Sandbox steps have RW access to their own output dir on the
+ * shared session storage, so a malicious or compromised step could create
+ * a symlink pointing outside the analysis tree (e.g. to /etc/passwd).
+ * `path.resolve` is purely lexical — only `realpath` catches symlink
+ * escapes — so we re-validate containment after canonicalization.
+ */
+async function resolveSource(path, analysisRoot) {
+    if (path.includes("\0")) {
+        return { ok: false, reason: `source contains null byte: ${path}` };
+    }
+    if (path.startsWith("/")) {
+        return { ok: false, reason: `source must be relative to analysis root: ${path}` };
+    }
+    const lexical = resolve(analysisRoot, path);
+    if (lexical !== analysisRoot && !lexical.startsWith(analysisRoot + sep)) {
+        return { ok: false, reason: `source escapes analysis root: ${path}` };
+    }
+    let canonical;
+    try {
+        canonical = await realpath(lexical);
+    }
+    catch (err) {
+        if (err.code === "ENOENT") {
+            return { ok: false, reason: `source not found: ${path}` };
+        }
+        throw err;
+    }
+    if (canonical !== analysisRoot && !canonical.startsWith(analysisRoot + sep)) {
+        return { ok: false, reason: `source escapes analysis root via symlink: ${path}` };
+    }
+    return { ok: true, path: canonical };
+}
+function resolveDestination(name, assetsDirAbs) {
+    if (name.includes("\0")) {
+        return { ok: false, reason: `destination contains null byte: ${name}` };
+    }
+    // Reject any path-y name — assets/ is intentionally flat. `as: "subdir/x"`
+    // would otherwise pass the starts-with check but fail at copyFile time
+    // because the parent dir doesn't exist, bubbling an unhandled exception
+    // out of stageReportAssets's {ok} contract.
+    if (name !== basename(name)) {
+        return { ok: false, reason: `destination must be a flat filename (no path separators): ${name}` };
+    }
+    const resolved = resolve(assetsDirAbs, name);
+    if (!resolved.startsWith(assetsDirAbs + sep)) {
+        return { ok: false, reason: `destination escapes assets dir: ${name}` };
+    }
+    return { ok: true, path: resolved };
+}
+function inferKind(name) {
+    const ext = extname(name).toLowerCase();
+    if (ext === ".csv")
+        return "csv";
+    if (ext === ".tsv")
+        return "tsv";
+    if (ext === ".png" || ext === ".jpg" || ext === ".jpeg" || ext === ".svg" || ext === ".gif" || ext === ".webp") {
+        return "image";
+    }
+    if (ext === ".json")
+        return "json";
+    return "other";
+}
+async function enrichTabular(path, delim) {
+    const fd = await open(path, "r");
+    try {
+        const buf = Buffer.alloc(HEAD_BUF_BYTES);
+        const { bytesRead } = await fd.read(buf, 0, HEAD_BUF_BYTES, 0);
+        const head = buf.subarray(0, bytesRead).toString("utf8");
+        const lines = head.split(/\r?\n/);
+        if (lines.length === 0 || lines[0].length === 0)
+            return {};
+        const columns = parseLine(lines[0], delim);
+        const headRows = [];
+        for (let i = 1; i < lines.length && headRows.length < HEAD_ROW_COUNT; i++) {
+            if (lines[i].length === 0)
+                continue;
+            headRows.push(parseLine(lines[i], delim));
+        }
+        const rowCount = await countRows(fd);
+        const result = {
+            columns,
+        };
+        if (headRows.length > 0)
+            result.headRows = headRows;
+        if (rowCount !== undefined)
+            result.rowCount = rowCount;
+        return result;
+    }
+    finally {
+        await fd.close();
+    }
+}
+function parseLine(line, delim) {
+    // Naive split — sufficient for analysis output where fields rarely contain
+    // delimiters or embedded newlines. The builder reads the actual file via the
+    // assets/ symlink for rendering; the brief just surfaces column names so the
+    // conv agent can compose section content correctly.
+    return line.split(delim).map((s) => s.replace(/^"|"$/g, ""));
+}
+/**
+ * Detect array-of-objects JSON shape so the brief surfaces columns + a few
+ * head rows the same way it does for CSV/TSV. Anything other than a top-level
+ * array of objects (e.g. ECharts options, scalar config, nested aggregates)
+ * is staged with no enrichment — the builder can still load it client-side
+ * and use it directly, but the conv agent picks chart encoding without
+ * column hints. Parses the full file; caller caps file size upstream.
+ */
+async function enrichJson(path) {
+    let parsed;
+    try {
+        const { readFile } = await import("node:fs/promises");
+        parsed = JSON.parse(await readFile(path, "utf8"));
+    }
+    catch {
+        return {};
+    }
+    if (!Array.isArray(parsed) || parsed.length === 0)
+        return {};
+    // Sample the first non-null object for keys. Mixed-shape arrays still get
+    // first-element keys — good enough for the brief; renderer reads the file
+    // directly anyway.
+    const first = parsed.find((r) => r && typeof r === "object" && !Array.isArray(r));
+    if (!first)
+        return { rowCount: parsed.length };
+    const columns = Object.keys(first);
+    const headRows = [];
+    for (let i = 0; i < parsed.length && headRows.length < HEAD_ROW_COUNT; i++) {
+        const r = parsed[i];
+        if (!r || typeof r !== "object" || Array.isArray(r))
+            continue;
+        const obj = r;
+        headRows.push(columns.map((c) => stringifyCell(obj[c])));
+    }
+    const result = {
+        columns,
+        rowCount: parsed.length,
+    };
+    if (headRows.length > 0)
+        result.headRows = headRows;
+    return result;
+}
+function stringifyCell(v) {
+    if (v === null || v === undefined)
+        return "";
+    if (typeof v === "string")
+        return v;
+    if (typeof v === "number" || typeof v === "boolean")
+        return String(v);
+    return JSON.stringify(v);
+}
+async function countRows(fd) {
+    const buf = Buffer.alloc(COUNT_CHUNK_BYTES);
+    let newlines = 0;
+    let pos = 0;
+    let lastByte = -1;
+    while (true) {
+        const { bytesRead } = await fd.read(buf, 0, buf.length, pos);
+        if (bytesRead === 0)
+            break;
+        for (let i = 0; i < bytesRead; i++) {
+            if (buf[i] === 0x0a)
+                newlines++;
+        }
+        lastByte = buf[bytesRead - 1];
+        pos += bytesRead;
+    }
+    if (pos === 0)
+        return 0;
+    // If the file doesn't end with a newline, the last row wasn't counted.
+    const total = lastByte === 0x0a ? newlines : newlines + 1;
+    // Subtract one for the header.
+    return Math.max(0, total - 1);
+}
+export function formatBytes(bytes) {
+    if (bytes < 1024)
+        return `${bytes}B`;
+    if (bytes < 1024 * 1024)
+        return `${(bytes / 1024).toFixed(1)}KB`;
+    if (bytes < 1024 * 1024 * 1024)
+        return `${(bytes / (1024 * 1024)).toFixed(1)}MB`;
+    return `${(bytes / (1024 * 1024 * 1024)).toFixed(2)}GB`;
+}

package/dist/tools/lib/string-client.d.ts

@@ -0,0 +1,33 @@
+/**
+ * Pure async client functions for STRING DB protein-protein interactions.
+ *
+ * Used by §3.8 (PPI Network).
+ */
+export interface StringInteraction {
+    proteinA: string;
+    proteinB: string;
+    score: number;
+    experimentalScore?: number;
+    databaseScore?: number;
+    textminingScore?: number;
+}
+export interface StringEnrichment {
+    category: string;
+    term: string;
+    description: string;
+    pValue: number;
+    fdr: number;
+    geneCount: number;
+    genes: string[];
+}
+export interface InteractionOptions {
+    species?: number;
+    minScore?: number;
+    limit?: number;
+}
+/** Fetch interaction partners (one-hop) for the given identifiers. */
+export declare function getInteractionPartners(identifiers: string[], options?: InteractionOptions): Promise<StringInteraction[]>;
+/** Fetch the network among the given identifiers. */
+export declare function getInteractionNetwork(identifiers: string[], options?: InteractionOptions): Promise<StringInteraction[]>;
+/** Functional enrichment for a gene set. */
+export declare function getEnrichment(identifiers: string[], species?: number): Promise<StringEnrichment[]>;

package/dist/tools/lib/string-client.js

@@ -0,0 +1,93 @@
+/**
+ * Pure async client functions for STRING DB protein-protein interactions.
+ *
+ * Used by §3.8 (PPI Network).
+ */
+import { z } from "zod";
+import { apiFetchValidated, describeApiError } from "./api-utils.js";
+const STRING_BASE = "https://string-db.org/api/json";
+const CALLER_IDENTITY = "inflexa_cortex";
+function buildParams(identifiers, species, extra = {}) {
+    const params = new URLSearchParams({
+        identifiers: identifiers.join("%0d"),
+        species: String(species),
+        caller_identity: CALLER_IDENTITY,
+    });
+    for (const [k, v] of Object.entries(extra)) {
+        params.set(k, String(v));
+    }
+    return params;
+}
+// One STRING interaction row (interaction/network endpoints). The `.object(...)` half is
+// the raw wire shape (every field optional — the API omits absent values); the
+// `.transform(...)` half normalizes it into the `StringInteraction` we return. Parsing IS
+// the validation: `apiFetchValidated` runs this over the JSON, so a field whose type drifts
+// is rejected as `invalid_response` rather than silently mis-mapped.
+const StringInteractionSchema = z
+    .object({
+    preferredName_A: z.string().optional(),
+    preferredName_B: z.string().optional(),
+    score: z.number().optional(),
+    escore: z.number().optional(),
+    dscore: z.number().optional(),
+    tscore: z.number().optional(),
+})
+    .transform((d) => ({
+    proteinA: d.preferredName_A ?? "",
+    proteinB: d.preferredName_B ?? "",
+    score: d.score ?? 0,
+    experimentalScore: d.escore ?? undefined,
+    databaseScore: d.dscore ?? undefined,
+    textminingScore: d.tscore ?? undefined,
+}));
+// One STRING enrichment row. `preferredNames` legitimately arrives as either a string array
+// or a single comma-joined string, so the schema accepts the union and the transform folds
+// both into a `string[]`.
+const StringEnrichmentSchema = z
+    .object({
+    category: z.string().optional(),
+    term: z.string().optional(),
+    description: z.string().optional(),
+    p_value: z.number().optional(),
+    fdr: z.number().optional(),
+    number_of_genes: z.number().optional(),
+    preferredNames: z.union([z.array(z.string()), z.string()]).optional(),
+})
+    .transform((d) => ({
+    category: d.category ?? "",
+    term: d.term ?? "",
+    description: d.description ?? "",
+    pValue: d.p_value ?? 1,
+    fdr: d.fdr ?? 1,
+    geneCount: d.number_of_genes ?? 0,
+    genes: Array.isArray(d.preferredNames) ? d.preferredNames : (d.preferredNames ?? "").split(",").filter(Boolean),
+}));
+/** Fetch interaction partners (one-hop) for the given identifiers. */
+export async function getInteractionPartners(identifiers, options = {}) {
+    const params = buildParams(identifiers, options.species ?? 9606, {
+        required_score: options.minScore ?? 400,
+        limit: options.limit ?? 20,
+    });
+    const res = await apiFetchValidated(`${STRING_BASE}/interaction_partners?${params}`, z.array(StringInteractionSchema));
+    if (res.isErr())
+        throw new Error(describeApiError(res.error));
+    return res.value.sort((a, b) => b.score - a.score);
+}
+/** Fetch the network among the given identifiers. */
+export async function getInteractionNetwork(identifiers, options = {}) {
+    const params = buildParams(identifiers, options.species ?? 9606, {
+        required_score: options.minScore ?? 400,
+    });
+    const res = await apiFetchValidated(`${STRING_BASE}/network?${params}`, z.array(StringInteractionSchema));
+    if (res.isErr())
+        throw new Error(describeApiError(res.error));
+    return res.value.sort((a, b) => b.score - a.score);
+}
+/** Functional enrichment for a gene set. */
+export async function getEnrichment(identifiers, species = 9606) {
+    const params = buildParams(identifiers, species);
+    const res = await apiFetchValidated(`${STRING_BASE}/enrichment?${params}`, z.array(StringEnrichmentSchema));
+    if (res.isErr())
+        throw new Error(describeApiError(res.error));
+    return res.value.sort((a, b) => a.fdr - b.fdr);
+}

package/dist/tools/lib/toxcast-config.d.ts

@@ -0,0 +1,2 @@
+export declare const EPA_CCTE_BASE = "https://comptox.epa.gov/ctx-api";
+export declare function getEpaCcteHeaders(apiKey: string): Record<string, string>;

package/dist/tools/lib/toxcast-config.js

@@ -0,0 +1,11 @@
+export const EPA_CCTE_BASE = "https://comptox.epa.gov/ctx-api";
+export function getEpaCcteHeaders(apiKey) {
+    const key = apiKey;
+    if (!key) {
+        throw new Error("EPA_CCTE_API_KEY environment variable is not set. " + "Obtain a free key from https://api.epa.gov/");
+    }
+    return {
+        "x-api-key": key,
+        Accept: "application/json",
+    };
+}

package/dist/tools/lib/uniprot-client.d.ts

@@ -0,0 +1,28 @@
+/**
+ * Pure async client functions for the UniProt REST API
+ * (https://rest.uniprot.org/uniprotkb/).
+ *
+ * Used by target-assessment as the source of truth for:
+ *   - ChEMBL cross-references — every ChEMBL target id linked to a UniProt
+ *     accession (replaces the hand-curated ALTERNATE_CHEMBL_IDS map).
+ *   - Protein family text — used together with IUPHAR family-target
+ *     resolution to identify sibling receptors in the same pharmacological
+ *     family (replaces the hand-curated RELATED_FAMILY_UNIPROTS map).
+ */
+export interface UniProtRecord {
+    primaryAccession: string;
+    uniProtkbId: string | null;
+    geneNames: string[];
+    chemblIds: string[];
+    reactomePathwayIds: string[];
+    proteinFamilyText: string | null;
+}
+/**
+ * Fetch a single UniProtKB entry by accession. Returns null on 404; throws
+ * on other HTTP errors so callers can surface upstream outages.
+ */
+export declare function getUniProtRecord(accession: string): Promise<UniProtRecord | null>;
+/** All ChEMBL target ids cross-referenced from a UniProt accession. */
+export declare function getChemblIdsByUniProt(accession: string): Promise<string[]>;
+/** All Reactome pathway ids cross-referenced from a UniProt accession. */
+export declare function getReactomePathwaysByUniProt(accession: string): Promise<string[]>;

package/dist/tools/lib/uniprot-client.js

@@ -0,0 +1,103 @@
+/**
+ * Pure async client functions for the UniProt REST API
+ * (https://rest.uniprot.org/uniprotkb/).
+ *
+ * Used by target-assessment as the source of truth for:
+ *   - ChEMBL cross-references — every ChEMBL target id linked to a UniProt
+ *     accession (replaces the hand-curated ALTERNATE_CHEMBL_IDS map).
+ *   - Protein family text — used together with IUPHAR family-target
+ *     resolution to identify sibling receptors in the same pharmacological
+ *     family (replaces the hand-curated RELATED_FAMILY_UNIPROTS map).
+ */
+import { z } from "zod";
+import { apiFetchValidated, describeApiError } from "./api-utils.js";
+import { UNIPROT_BASE, UNIPROT_HEADERS } from "./uniprot-config.js";
+const RawCommentSchema = z.object({
+    commentType: z.string().optional(),
+    texts: z.array(z.object({ value: z.string().optional() })).optional(),
+});
+const FIELDS = ["accession", "id", "gene_names", "xref_chembl", "xref_reactome", "cc_similarity"].join(",");
+function extractFamilyText(comments) {
+    if (!comments)
+        return null;
+    for (const c of comments) {
+        if (c.commentType !== "SIMILARITY")
+            continue;
+        for (const t of c.texts ?? []) {
+            const v = t.value?.trim();
+            if (v)
+                return v;
+        }
+    }
+    return null;
+}
+// A single schema that both validates the raw UniProtKB wire shape and
+// normalizes it into the `UniProtRecord` we return. Every field is optional
+// because the API omits absent values; parsing IS the validation, so a payload
+// whose field TYPES drift is rejected as `invalid_response` rather than silently
+// mis-mapped. `z.infer` of the transform is the `UniProtRecord` output type.
+const UniProtRecordSchema = z
+    .object({
+    primaryAccession: z.string().optional(),
+    uniProtkbId: z.string().optional(),
+    genes: z
+        .array(z.object({
+        geneName: z.object({ value: z.string().optional() }).optional(),
+        synonyms: z.array(z.object({ value: z.string().optional() })).optional(),
+    }))
+        .optional(),
+    uniProtKBCrossReferences: z.array(z.object({ database: z.string().optional(), id: z.string().optional() })).optional(),
+    comments: z.array(RawCommentSchema).optional(),
+})
+    .transform((raw) => {
+    const chemblIds = [];
+    const reactomeIds = [];
+    for (const x of raw.uniProtKBCrossReferences ?? []) {
+        if (!x.id)
+            continue;
+        if (x.database === "ChEMBL")
+            chemblIds.push(x.id);
+        else if (x.database === "Reactome")
+            reactomeIds.push(x.id);
+    }
+    const geneNames = [];
+    for (const g of raw.genes ?? []) {
+        const name = g.geneName?.value;
+        if (name)
+            geneNames.push(name);
+    }
+    return {
+        primaryAccession: raw.primaryAccession ?? "",
+        uniProtkbId: raw.uniProtkbId ?? null,
+        geneNames,
+        chemblIds,
+        reactomePathwayIds: reactomeIds,
+        proteinFamilyText: extractFamilyText(raw.comments),
+    };
+});
+/**
+ * Fetch a single UniProtKB entry by accession. Returns null on 404; throws
+ * on other HTTP errors so callers can surface upstream outages.
+ */
+export async function getUniProtRecord(accession) {
+    const url = `${UNIPROT_BASE}/uniprotkb/${encodeURIComponent(accession)}?fields=${FIELDS}&format=json`;
+    const res = await apiFetchValidated(url, UniProtRecordSchema, { headers: UNIPROT_HEADERS });
+    if (res.isErr()) {
+        if (res.error.type === "http_status" && res.error.status === 404)
+            return null;
+        throw new Error(describeApiError(res.error));
+    }
+    if (!res.value.primaryAccession)
+        return null;
+    return res.value;
+}
+/** All ChEMBL target ids cross-referenced from a UniProt accession. */
+export async function getChemblIdsByUniProt(accession) {
+    const rec = await getUniProtRecord(accession);
+    return rec?.chemblIds ?? [];
+}
+/** All Reactome pathway ids cross-referenced from a UniProt accession. */
+export async function getReactomePathwaysByUniProt(accession) {
+    const rec = await getUniProtRecord(accession);
+    return rec?.reactomePathwayIds ?? [];
+}

package/dist/tools/lib/uniprot-config.d.ts

@@ -0,0 +1,5 @@
+/** Shared constants for the UniProt REST API. */
+export declare const UNIPROT_BASE = "https://rest.uniprot.org";
+export declare const UNIPROT_HEADERS: {
+    readonly Accept: "application/json";
+};

package/dist/tools/lib/uniprot-config.js

@@ -0,0 +1,3 @@
+/** Shared constants for the UniProt REST API. */
+export const UNIPROT_BASE = "https://rest.uniprot.org";
+export const UNIPROT_HEADERS = { Accept: "application/json" };

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

@@ -0,0 +1,4 @@
+/**
+ * Memory barrel — working-memory read/update tool.
+ */
+export * from "./update-working-memory.js";

package/dist/tools/memory/index.js

@@ -0,0 +1,4 @@
+/**
+ * Memory barrel — working-memory read/update tool.
+ */
+export * from "./update-working-memory.js";

package/dist/tools/memory/update-working-memory.d.ts

@@ -0,0 +1,25 @@
+/**
+ * update-working-memory — the agent's single interface for maintaining
+ * working memory.
+ *
+ * Dependency-bearing: the `WorkingMemoryStore` is captured by the factory
+ * (see the harness-durable-runtime spec). The analysis id is read from the request-scoped `Session`.
+ *
+ * The input is a flat object with a `section` discriminator — not a
+ * `z.discriminatedUnion`, which `defineTool` rejects (Anthropic needs a
+ * top-level `"type":"object"`). The variant fields are validated by
+ * `.refine` so a malformed call (e.g. a `finding` with no `runId`) fails
+ * at the loop boundary and surfaces as an `is_error` tool result.
+ */
+import type { WorkingMemoryStore } from "../../memory/working-memory.js";
+export declare function createUpdateWorkingMemoryTool(workingMemory: WorkingMemoryStore): import("../define-tool.js").Tool<{
+    section: "constraint" | "goal" | "hypothesis" | "finding";
+    operation?: "add" | "revise" | "retire" | undefined;
+    text?: string | undefined;
+    id?: string | undefined;
+    origin?: "user" | "agent" | undefined;
+    runId?: string | undefined;
+}, {
+    ok: boolean;
+    section: "constraint" | "goal" | "hypothesis" | "finding";
+}>;