@inflexa-ai/harness 0.19.0 → 0.19.1

package/dist/tools/report-session/record-version.js

@@ -0,0 +1,139 @@
+/**
+ * The record tool of a report session.
+ *
+ * The tool records one version of the report. The store is append-only with no delete, thus a version that
+ * the gate did not accept must never exist. The tool runs the whole gate first, and only a pass reaches the
+ * store.
+ *
+ * The gate has three parts, in order of cost. The finish gates the schema, the unique ids, and the
+ * structural tier, and a gap list returns as data. The look-before-record rule then compares the seen hash
+ * against the hash of the current draft, on the state that the load already read. A never-seen page and a
+ * stale look each refuse with a distinct reason, and the rule reads no model judgment. The full validation
+ * resolves every reference through the injected resolver, matches each chart encoding, and matches each
+ * assert. A failure names the block that holds the failed part, thus the agent repairs one block and not the
+ * report at large.
+ *
+ * The look runs before the validation on purpose. The validation builds the resolver and its prepare pass
+ * can start a container, thus the cheap look guards the expensive pass. A never-seen or stale draft refuses
+ * before the resolver constructs.
+ *
+ * On a pass the store records the document that the gate validated, the pinned snapshot, and the anchor from
+ * the thread row. The one-per-thread rule of the store bounds a concurrent race, and that refusal returns as
+ * data. The outcome of a pass carries the version id.
+ */
+import { ok } from "neverthrow";
+import { z } from "zod";
+import { createNoopLogger } from "../../lib/console-logger.js";
+import { describeDbError } from "../../lib/db-result.js";
+import { finishDraft } from "../../report-model/draft-finish.js";
+import { computeDraftHash } from "../../report-model/draft-hash.js";
+import { validateReport } from "../../report-model/validate.js";
+import { defineTool } from "../define-tool.js";
+import { openReportThread } from "../report-authoring/authoring-tools.js";
+/** The empty input. The tool records the current draft of the thread, thus it needs no field. */
+const recordVersionInput = z.object({});
+/** A short account of a record refusal, for the detail of a transient failure. */
+function describeRecordFailure(error) {
+    switch (error.type) {
+        case "malformed_document":
+            return "the gate accepted a document that the store read as malformed";
+        case "malformed_snapshot":
+            return "the pinned snapshot is malformed";
+        case "parent_analysis_mismatch":
+            return "the parent version belongs to a different analysis";
+        case "thread_already_holds_version":
+            return "the thread already holds a recorded version";
+        default:
+            return describeDbError(error);
+    }
+}
+/**
+ * Make the record tool over the session-state gateway, the version store, the thread store, and the
+ * resolver.
+ *
+ * The tool reads the thread id from the scope of the call, and it loads the state through the gateway. Thus
+ * one factory serves every thread. The tool holds no per-session value.
+ */
+export function createRecordVersionTool(deps) {
+    const logger = (deps.logger ?? createNoopLogger()).named("record-report-version");
+    return defineTool({
+        id: "record_report_version",
+        description: "Record the current draft as one report version. The tool runs the whole gate first: it finishes the draft, " +
+            "resolves each reference, matches each chart encoding, and matches each assert. An incomplete draft gives back the gap list, " +
+            "and a failed reference gives back the block that broke. The tool records a version only after the eyes look at the current page. " +
+            "A thread holds one version, thus a second record gives back that the thread already holds one.",
+        inputSchema: recordVersionInput,
+        executionMode: "inline",
+        describeCall: "none",
+        execute: async (_input, ctx) => {
+            const opened = await openReportThread(deps.gateway, ctx.session.scope);
+            if (opened.isErr()) {
+                return ok({ outcome: "refused", refusal: opened.error });
+            }
+            const { threadId, analysisId, state, seenDocumentHash } = opened.value;
+            const { document: draft, snapshot } = state;
+            const finished = finishDraft(draft, snapshot);
+            if (!finished.valid) {
+                return ok({ outcome: "gaps", gaps: finished.gaps });
+            }
+            // The look-before-record rule runs before the resolver and the validation, on the state that the
+            // load already read. The preview stamps the rendered hash, and the eyes copy it onto the seen
+            // hash. A never-seen page carries no seen hash. A stale look carries the hash of an earlier draft,
+            // thus a mismatch against the current draft refuses. Each refusal skips the expensive validation.
+            const currentHash = computeDraftHash(draft);
+            if (seenDocumentHash === null) {
+                return ok({ outcome: "never-seen" });
+            }
+            if (seenDocumentHash !== currentHash) {
+                return ok({ outcome: "stale-look" });
+            }
+            if (deps.makeResolver === undefined) {
+                return ok({ outcome: "resolver-unavailable" });
+            }
+            // The resolver construction resolves the workspace root inside, and that seam throws on an
+            // unresolvable root. The guard turns the throw into a typed outcome that names the fault, thus a
+            // control-flow exception propagates and the unresolvable root does not.
+            let resolver;
+            try {
+                resolver = deps.makeResolver({ analysisId, auth: ctx.session.auth });
+            }
+            catch (cause) {
+                logger.warn("the workspace root did not resolve", { threadId, analysisId, ...logger.errorFields(cause) });
+                return ok({ outcome: "root-unresolvable", detail: "the workspace root did not resolve" });
+            }
+            const validation = await validateReport(finished.document, snapshot, resolver);
+            if (!validation.valid) {
+                return ok({
+                    outcome: "invalid",
+                    ...(validation.schemaIssues ? { schemaIssues: validation.schemaIssues } : {}),
+                    ...(validation.duplicateIds ? { duplicateIds: validation.duplicateIds } : {}),
+                    ...(validation.resolutionFailures ? { resolutionFailures: validation.resolutionFailures } : {}),
+                });
+            }
+            const thread = await deps.threads.getThread(threadId);
+            if (thread.isErr()) {
+                logger.warn("the thread row read failed", { threadId, analysisId, ...logger.errorFields(thread.error.cause) });
+                return ok({ outcome: "record-failed", detail: describeDbError(thread.error) });
+            }
+            if (thread.value === null) {
+                logger.warn("the report thread row is absent at record", { threadId, analysisId });
+                return ok({ outcome: "record-failed", detail: "the report thread row is absent" });
+            }
+            const recorded = await deps.store.record({
+                document: finished.document,
+                snapshot,
+                analysisId,
+                threadId,
+                parentThreadId: thread.value.parentThreadId,
+                parentSeq: thread.value.parentSeq,
+            });
+            return recorded.match((ref) => ok({ outcome: "recorded", versionId: ref.versionId }), (error) => {
+                if (error.type === "thread_already_holds_version") {
+                    return ok({ outcome: "already-recorded" });
+                }
+                logger.warn("the version did not record", { threadId, analysisId, reason: error.type });
+                return ok({ outcome: "record-failed", detail: describeRecordFailure(error) });
+            });
+        },
+    });
+}

package/dist/tools/sandbox/list-available-packages.js

@@ -27,12 +27,13 @@ import { ok } from "neverthrow";
 import { z } from "zod";
 import { defineTool } from "../define-tool.js";
 import { capCodePoints, DETAIL_NEEDLE_MAX_LENGTH } from "../../loop/tool-detail.js";
+import { LIBS_CONTAINER_PATH } from "../../sandbox/mount-plan.js";
 /**
  * Where the list lives when the host mounts the library store at the same path
  * the sandbox does. Hosts that do not — the store is baked into the image and
  * never bind-mounted — inject their own path instead.
  */
-const DEFAULT_PACKAGES_FILE = "/mnt/libs/current/packages.txt";
+const DEFAULT_PACKAGES_FILE = `${LIBS_CONTAINER_PATH}/current/packages.txt`;
 /**
  * Default cap on a listing — high enough that the real store is never truncated.
  * The shipped catalog is ~270 packages (~3 KB, well under a thousand tokens), so

package/dist/tools/sandbox/list-available-refs.d.ts

@@ -14,7 +14,11 @@
  * it at — read where it lives, render where the caller will open it. Reading it
  * host-side is what lets a planner ask what reference data exists before any
  * sandbox is created; a step agent asking mid-run sees the same store, because
- * the mount and this path are the same bytes.
+ * the mount and this path are the same bytes. An omitted `refStorePath` falls
+ * back to that same container path — where a host that mounts the store into its
+ * own process (a K8s pod holding the ref-store PVC) already sees it. The fallback
+ * is stat-verified like any other root, so a host with nothing mounted there
+ * still reports the store as unavailable.
  *
  * The scan reports paths; meaning is joined on afterwards from the install
  * receipt and the catalog it names (organism, format, and each file's internal

package/dist/tools/sandbox/list-available-refs.js

@@ -14,7 +14,11 @@
  * it at — read where it lives, render where the caller will open it. Reading it
  * host-side is what lets a planner ask what reference data exists before any
  * sandbox is created; a step agent asking mid-run sees the same store, because
- * the mount and this path are the same bytes.
+ * the mount and this path are the same bytes. An omitted `refStorePath` falls
+ * back to that same container path — where a host that mounts the store into its
+ * own process (a K8s pod holding the ref-store PVC) already sees it. The fallback
+ * is stat-verified like any other root, so a host with nothing mounted there
+ * still reports the store as unavailable.
  *
  * The scan reports paths; meaning is joined on afterwards from the install
  * receipt and the catalog it names (organism, format, and each file's internal
@@ -30,9 +34,13 @@ import { z } from "zod";
 import { capCodePoints, DETAIL_MAX_LENGTH, DETAIL_NEEDLE_MAX_LENGTH } from "../../loop/tool-detail.js";
 import { REFERENCE_DATA_CATALOG } from "../../reference-data/catalog.js";
 import { parseReferenceInstallReceipt } from "../../reference-data/receipt.js";
+import { REFS_CONTAINER_PATH } from "../../sandbox/mount-plan.js";
 import { defineTool } from "../define-tool.js";
-/** Container path the ref store is mounted at; every reported path is rendered under it. */
-const REFS_ROOT = "/mnt/refs";
+/**
+ * Container path the ref store is mounted at: every reported path is rendered
+ * under it, and it is the read root when the embedder supplies none.
+ */
+const REFS_ROOT = REFS_CONTAINER_PATH;
 const MAX_ENTRIES = 200;
 const MAX_SCANNED_ENTRIES = 2_000;
 const MAX_PATH_BYTES = 40_000;
@@ -283,8 +291,6 @@ async function collectFiles(directory, relative, budget) {
  */
 async function scanStore(root, relative, recursive = false) {
     const empty = () => ({ entries: [], scannedEntries: 0, truncated: false });
-    if (!root)
-        return { state: "unavailable", ...empty() };
     try {
         if (!(await lstat(root)).isDirectory())
             return { state: "unavailable", ...empty() };
@@ -494,6 +500,7 @@ function renderContent(path, scan, entries) {
 }
 /** Create reference discovery over the host-visible reference store. */
 export function createListAvailableRefsTool(deps) {
+    const storeRoot = deps.refStorePath ?? REFS_ROOT;
     return defineTool({
         id: "list_available_refs",
         description: "Resolve reference data you need into a real path. Reports the reference data provisioned for this environment right now — the only reference data an analysis script can open. " +
@@ -570,7 +577,7 @@ export function createListAvailableRefsTool(deps) {
             // recursive pass a search from the store root only ever sees directories,
             // which carry no dataset labels, so "find me a regulon network" finds nothing.
             const needleGiven = (query?.trim() ?? "") !== "";
-            const raw = await scanStore(deps.refStorePath, posixPath.relative(REFS_ROOT, requested.path) || ".", needleGiven);
+            const raw = await scanStore(storeRoot, posixPath.relative(REFS_ROOT, requested.path) || ".", needleGiven);
             const enriched = enrichEntries(raw.entries, raw);
             const categories = collectCategories(enriched);
             const needle = query?.trim().toLowerCase();

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "@inflexa-ai/harness",
-    "version": "0.19.0",
+    "version": "0.19.1",
     "description": "Host-agnostic bioinformatics agent harness \u2014 hand-rolled agent loop, DBOS-durable workflows, sandboxed compute.",
     "license": "Apache-2.0",
     "type": "module",
@@ -44,11 +44,12 @@
         "typecheck": "tsc --noEmit"
     },
     "dependencies": {
-        "@ai-sdk/anthropic": "^4.0.20",
-        "@ai-sdk/openai-compatible": "^3.0.10",
-        "@ai-sdk/provider": "^4.0.3",
-        "@ai-sdk/provider-utils": "5.0.10",
-        "@anthropic-ai/sdk": "^0.107.0",
+        "@ai-sdk/anthropic": "^4.0.38",
+        "@ai-sdk/openai": "^4.0.39",
+        "@ai-sdk/openai-compatible": "^3.0.30",
+        "@ai-sdk/provider": "^4.0.7",
+        "@ai-sdk/provider-utils": "5.0.27",
+        "@anthropic-ai/sdk": "^0.116.0",
         "@dbos-inc/dbos-sdk": "^4.23.6",
         "@kubernetes/client-node": "^1.4.0",
         "@opentelemetry/api": "^1.9.1",
@@ -60,17 +61,18 @@
         "@opentelemetry/sdk-trace-base": "^2.9.0",
         "@opentelemetry/sdk-trace-node": "^2.9.0",
         "@opentelemetry/semantic-conventions": "^1.43.0",
-        "ai": "^7.0.28",
+        "ai": "^7.0.61",
         "cheerio": "^1.2.0",
         "dockerode": "^4.0.12",
         "fast-xml-parser": "^5.10.0",
         "hono": "^4.12.30",
+        "hyparquet": "^1.28.1",
         "js-tiktoken": "^1.0.21",
         "mime": "^4.1.0",
         "nanoid": "^5.1.16",
         "neverthrow": "^8.2.0",
         "nunjucks": "^3.2.4",
-        "openai": "^4.104.0",
+        "openai": "^7.4.0",
         "p-queue": "^9.3.3",
         "pdf-parse": "^2.4.5",
         "pg": "^8.22.0",