@inflexa-ai/harness 0.16.0 → 0.17.0

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

@@ -1,96 +1,10 @@
-/**
- * Search arXiv for preprints. Returns Atom XML which we parse without a
- * dependency. arXiv is the primary source for ML / physics / math /
- * control-theory preprints; Semantic Scholar lags it by months.
- *
- * Same wire call and envelope as the legacy tool. Stateless HTTP; no deps.
- */
+/** Search arXiv for preprints through the shared authority client. */
 import { ok } from "neverthrow";
 import { z } from "zod";
+import { createArxivSource } from "../../literature/sources/arxiv.js";
 import { defineTool } from "../define-tool.js";
-import { apiFetch, describeApiError } from "../lib/api-utils.js";
-const BASE_URL = "https://export.arxiv.org/api/query";
-const stripCdata = (s) => s.replace(/<!\[CDATA\[([\s\S]*?)\]\]>/g, "$1");
-const decodeXmlEntities = (s) => s
-    .replace(/&lt;/g, "<")
-    .replace(/&gt;/g, ">")
-    .replace(/&quot;/g, '"')
-    .replace(/&apos;/g, "'")
-    .replace(/&#x([0-9a-fA-F]+);/g, (_, h) => String.fromCodePoint(parseInt(h, 16)))
-    .replace(/&#(\d+);/g, (_, d) => String.fromCodePoint(parseInt(d, 10)))
-    .replace(/&amp;/g, "&"); // amp last so we don't double-decode
-const collapseWs = (s) => decodeXmlEntities(stripCdata(s)).replace(/\s+/g, " ").trim();
-const extractEntries = (xml) => {
-    const re = /<entry\b[^>]*>([\s\S]*?)<\/entry>/g;
-    const out = [];
-    let m;
-    while ((m = re.exec(xml)) !== null)
-        out.push(m[1]);
-    return out;
-};
-const firstMatch = (entry, tag) => {
-    const re = new RegExp(`<${tag}\\b[^>]*>([\\s\\S]*?)</${tag}>`);
-    const m = entry.match(re);
-    return m?.[1];
-};
-const allMatches = (entry, tag) => {
-    const re = new RegExp(`<${tag}\\b[^>]*>([\\s\\S]*?)</${tag}>`, "g");
-    const out = [];
-    let m;
-    while ((m = re.exec(entry)) !== null)
-        out.push(m[1]);
-    return out;
-};
-const linkAttr = (entry, predicate) => {
-    const re = /<link\b([^>]*)\/>/g;
-    let m;
-    while ((m = re.exec(entry)) !== null) {
-        if (predicate(m[1])) {
-            const hrefMatch = m[1].match(/href="([^"]+)"/);
-            if (hrefMatch)
-                return hrefMatch[1];
-        }
-    }
-    return undefined;
-};
-const categoryTerms = (entry) => {
-    const re = /<category\b([^>]*)\/>/g;
-    const out = [];
-    let m;
-    while ((m = re.exec(entry)) !== null) {
-        const termMatch = m[1].match(/term="([^"]+)"/);
-        if (termMatch)
-            out.push(termMatch[1]);
-    }
-    return out;
-};
-export function parseArxivAtom(xml) {
-    return extractEntries(xml).flatMap((entry) => {
-        const idRaw = firstMatch(entry, "id");
-        const title = firstMatch(entry, "title");
-        if (!idRaw || !title)
-            return [];
-        const idMatch = idRaw.match(/abs\/(.+)$/);
-        const authors = allMatches(entry, "author")
-            .map((a) => firstMatch(a, "name"))
-            .filter((n) => !!n)
-            .map(collapseWs);
-        const htmlUrl = linkAttr(entry, (a) => /rel="alternate"/.test(a) && /type="text\/html"/.test(a));
-        const pdfUrl = linkAttr(entry, (a) => /title="pdf"/.test(a));
-        return [
-            {
-                id: idMatch?.[1] ?? collapseWs(idRaw),
-                title: collapseWs(title),
-                abstract: collapseWs(firstMatch(entry, "summary") ?? ""),
-                authors,
-                published: collapseWs(firstMatch(entry, "published") ?? ""),
-                categories: categoryTerms(entry),
-                url: htmlUrl ?? collapseWs(idRaw),
-                pdfUrl,
-            },
-        ];
-    });
-}
+export { parseArxivAtom } from "../../literature/sources/arxiv.js";
+const source = createArxivSource({ maxRetries: 3, retryDelayMs: 1_000, timeoutMs: 90_000 });
 export const searchArxivTool = defineTool({
     id: "search_arxiv",
     description: "Search arXiv for preprints in ML, physics, math, control theory, " +
@@ -104,20 +18,10 @@ export const searchArxivTool = defineTool({
             .describe('Optional arXiv category filters (e.g., ["cs.LG", "math.OC"]). ' + "Combined with the query using AND."),
         limit: z.number().int().min(1).max(20).default(10).describe("Maximum results (1–20, default 10)."),
     }),
-    execute: async ({ query, categories, limit }) => {
-        const catPart = categories && categories.length > 0 ? ` AND (${categories.map((c) => `cat:${c}`).join(" OR ")})` : "";
-        const params = new URLSearchParams({
-            search_query: `all:${query}${catPart}`,
-            max_results: String(limit),
-            sortBy: "relevance",
-            sortOrder: "descending",
-        });
-        const res = await apiFetch(`${BASE_URL}?${params}`, {
-            parseAs: "text",
-        });
-        if (res.isErr()) {
-            return ok({ success: false, error: describeApiError(res.error), papers: [] });
-        }
-        return ok({ success: true, papers: parseArxivAtom(res.value) });
+    execute: async ({ query, categories, limit }, context) => {
+        const result = await source.search({ query, ...(categories === undefined ? {} : { categories }), limit }, context.signal);
+        if (result.status !== "ok")
+            return ok({ success: false, error: result.detail, papers: [] });
+        return ok({ success: true, papers: result.value });
     },
 });

package/dist/tools/research/search-semantic-scholar.d.ts

@@ -1,33 +1,8 @@
-/**
- * Search Semantic Scholar Graph API for academic papers across all
- * sciences. No API key required; rate-limited but reasonable for agent
- * use. Used by the analogical-reasoner for cross-domain analogical search.
- *
- * Same wire call and envelope as the legacy tool, packaged as `defineTool`.
- * Stateless HTTP; no deps.
- */
-export interface SemanticScholarPaper {
-    id: string;
-    title: string;
-    abstract?: string;
-    year?: number;
-    venue?: string;
-    citationCount?: number;
-    url?: string;
-    authors: string[];
-    externalIds?: Record<string, string>;
-}
-type SearchSemanticScholarOutput = {
-    success: false;
-    error: string;
-    papers: SemanticScholarPaper[];
-} | {
-    success: true;
-    papers: SemanticScholarPaper[];
-};
-export declare function parseSemanticScholarResponse(raw: unknown): SemanticScholarPaper[];
-export declare const searchSemanticScholarTool: import("../define-tool.js").Tool<{
-    query: string;
-    limit: number;
-}, SearchSemanticScholarOutput>;
-export {};
+/** Search Semantic Scholar through the shared authority client. */
+import { type SemanticScholarSearchPaper } from "../../literature/sources/semantic-scholar.js";
+import { type Tool } from "../define-tool.js";
+export { parseSemanticScholarResponse } from "../../literature/sources/semantic-scholar.js";
+export type SemanticScholarPaper = SemanticScholarSearchPaper;
+export declare function createSearchSemanticScholarTool(options?: {
+    readonly apiKey?: string;
+}): Tool;

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

@@ -1,93 +1,34 @@
-/**
- * Search Semantic Scholar Graph API for academic papers across all
- * sciences. No API key required; rate-limited but reasonable for agent
- * use. Used by the analogical-reasoner for cross-domain analogical search.
- *
- * Same wire call and envelope as the legacy tool, packaged as `defineTool`.
- * Stateless HTTP; no deps.
- */
+/** Search Semantic Scholar through the shared authority client. */
 import { ok } from "neverthrow";
 import { z } from "zod";
+import { createSemanticScholarSource } from "../../literature/sources/semantic-scholar.js";
 import { defineTool } from "../define-tool.js";
-import { apiFetchValidated, describeApiError } from "../lib/api-utils.js";
-const BASE_URL = "https://api.semanticscholar.org/graph/v1";
-const DEFAULT_FIELDS = "paperId,title,abstract,year,venue,citationCount,url,authors,externalIds";
-// Raw Semantic Scholar wire shape, validated at the fetch boundary. Every field
-// is optional — `parseSemanticScholarResponse` already filters/coerces defensively,
-// so a partial-but-valid response must still parse; `externalIds` values stay
-// unconstrained (`z.unknown`) since the mapper only checks the container is an object.
-// The scalar fields are also `.nullable()`: Semantic Scholar sends an explicit
-// `null` for a missing abstract/year/venue/url/externalIds (very common), which a
-// bare `.optional()` would reject — failing the whole `data` array on one such paper.
-const SemanticScholarResponseSchema = z.object({
-    data: z
-        .array(z.object({
-        paperId: z.string().optional(),
-        title: z.string().optional(),
-        abstract: z.string().nullable().optional(),
-        year: z.number().nullable().optional(),
-        venue: z.string().nullable().optional(),
-        citationCount: z.number().nullable().optional(),
-        url: z.string().nullable().optional(),
-        authors: z.array(z.object({ name: z.string().nullable().optional() })).optional(),
-        externalIds: z.record(z.string(), z.unknown()).nullable().optional(),
-    }))
-        .optional(),
-});
-export function parseSemanticScholarResponse(raw) {
-    const data = raw?.data;
-    if (!Array.isArray(data))
-        return [];
-    return data
-        .filter((p) => typeof p === "object" && p !== null && "paperId" in p && "title" in p)
-        .map((p) => {
-        const authors = Array.isArray(p.authors)
-            ? p.authors.map((a) => a?.name).filter((n) => typeof n === "string")
-            : [];
-        return {
-            id: String(p.paperId),
-            title: String(p.title),
-            abstract: typeof p.abstract === "string" ? p.abstract : undefined,
-            year: typeof p.year === "number" ? p.year : undefined,
-            venue: typeof p.venue === "string" ? p.venue : undefined,
-            citationCount: typeof p.citationCount === "number" ? p.citationCount : undefined,
-            url: typeof p.url === "string" ? p.url : undefined,
-            authors,
-            externalIds: p.externalIds && typeof p.externalIds === "object" ? p.externalIds : undefined,
-        };
+export { parseSemanticScholarResponse } from "../../literature/sources/semantic-scholar.js";
+export function createSearchSemanticScholarTool(options = {}) {
+    const source = createSemanticScholarSource({
+        maxRetries: 3,
+        retryDelayMs: 1_000,
+        timeoutMs: 90_000,
+        ...(options.apiKey === undefined ? {} : { apiKey: options.apiKey }),
+    });
+    return defineTool({
+        id: "search_semantic_scholar",
+        description: "Search Semantic Scholar for academic papers across all sciences " +
+            "(biology, ML, physics, math, economics, engineering, etc.). Returns " +
+            "paper id, title, abstract, year, venue, citation count, authors, and " +
+            "external IDs (DOI, ArXiv). Best for cross-domain analogical search.",
+        inputSchema: z.object({
+            query: z
+                .string()
+                .describe("Free-text query. Use natural language phrases such as " +
+                '"reinforcement learning for control" or "feedback stabilisation in oscillators".'),
+            limit: z.number().int().min(1).max(20).default(10).describe("Maximum number of results to return (1–20, default 10)."),
+        }),
+        execute: async ({ query, limit }, context) => {
+            const result = await source.search(query, limit, context.signal);
+            if (result.status !== "ok")
+                return ok({ success: false, error: result.detail, papers: [] });
+            return ok({ success: true, papers: result.value });
+        },
     });
 }
-export const searchSemanticScholarTool = defineTool({
-    id: "search_semantic_scholar",
-    description: "Search Semantic Scholar for academic papers across all sciences " +
-        "(biology, ML, physics, math, economics, engineering, etc.). Returns " +
-        "paper id, title, abstract, year, venue, citation count, authors, and " +
-        "external IDs (DOI, ArXiv). Best for cross-domain analogical search.",
-    inputSchema: z.object({
-        query: z
-            .string()
-            .describe("Free-text query. Use natural language phrases such as " + '"reinforcement learning for control" or "feedback stabilisation in oscillators".'),
-        limit: z.number().int().min(1).max(20).default(10).describe("Maximum number of results to return (1–20, default 10)."),
-    }),
-    execute: async ({ query, limit }) => {
-        const params = new URLSearchParams({
-            query,
-            limit: String(limit),
-            fields: DEFAULT_FIELDS,
-        });
-        const apiKey = process.env.SEMANTIC_SCHOLAR_API_KEY;
-        const headers = {};
-        if (apiKey)
-            headers["x-api-key"] = apiKey;
-        const res = await apiFetchValidated(`${BASE_URL}/paper/search?${params}`, SemanticScholarResponseSchema, {
-            headers,
-        });
-        if (res.isErr()) {
-            return ok({ success: false, error: describeApiError(res.error), papers: [] });
-        }
-        return ok({
-            success: true,
-            papers: parseSemanticScholarResponse(res.value),
-        });
-    },
-});

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

@@ -318,9 +318,8 @@ async function scanStore(root, relative, recursive = false) {
     const entries = [];
     let scanned = 0;
     let pathBytes = 0;
-    let truncated = false;
     const { values: children, cut } = await cappedEntries(target, Math.min(MAX_ENTRIES + 2, MAX_SCANNED_ENTRIES));
-    truncated = cut;
+    let truncated = cut;
     for (const child of children) {
         const childRelative = relative === "." ? child.name : `${relative}/${child.name}`;
         if (childRelative === ".inflexa" || childRelative.startsWith(".inflexa/") || childRelative === "registry.json")

package/dist/workflows/execute-analysis.d.ts

@@ -64,6 +64,7 @@ import type { RunSession } from "../auth/types.js";
 import type { RunAuthorizer } from "../execution/run-authorizer.js";
 import type { Logger } from "../lib/logger.js";
 import type { UsageRecorder } from "../billing/usage-recorder.js";
+import type { CitationResolver } from "../citations/types.js";
 import type { SynthesisStatus, UpdateStepExecutionInput } from "../state/index.js";
 import type { AnalysisStep } from "../schemas/workflow-state.js";
 import type { ChatProvider, EmbeddingProvider } from "../providers/types.js";
@@ -277,6 +278,8 @@ export interface ExecuteAnalysisDeps {
     readonly synthesisModel: string;
     /** API keys for the bio/chem tools the embedded literature reviewer uses. */
     readonly bioKeys: BioToolKeys;
+    /** Shared resolver for the literature reviewer used during synthesis. */
+    readonly citationResolver: CitationResolver;
     /** Run-level billing-bracket seam (managed: external bracket; OSS: no-op). */
     readonly runCharge: RunCharge;
     /** Run-authorization seam — the terminal path revokes through `revoke`. */

package/dist/workflows/execute-analysis.js

@@ -320,6 +320,7 @@ export function synthesizeFindings(args) {
         resolveWorkspaceRoot: deps.resolveWorkspaceRoot,
         synthesisModel: deps.synthesisModel,
         bioKeys: deps.bioKeys,
+        citationResolver: deps.citationResolver,
         usageRecorder: deps.usageRecorder,
     }, {
         analysisId,

package/dist/workflows/sandbox-step.d.ts

@@ -30,6 +30,7 @@ import type { TokenUsageRollup } from "@inflexa-ai/harness/contracts/usage.js";
 import type { Pool } from "pg";
 import type { Logger } from "../lib/logger.js";
 import type { UsageRecorder } from "../billing/usage-recorder.js";
+import type { CitationResolver } from "../citations/types.js";
 import type { AgentDefinition, LoopMessage } from "../loop/types.js";
 import type { AgentChat, EmbeddingProvider } from "../providers/types.js";
 import { type RunSession } from "../auth/types.js";
@@ -200,6 +201,8 @@ export interface SandboxAgentBuildContext {
      * bound to this holder.
      */
     readonly blockerHolder: BlockerHolder;
+    /** Shared host-side citation resolver for allowlisted sandbox agents. */
+    readonly citationResolver: CitationResolver;
 }
 /**
  * Inversion of control: the parent supplies the live agent, the parent's
@@ -222,6 +225,8 @@ export interface SandboxStepDeps {
      * post-step sub-agent loops alike; omitted falls back to the no-op recorder.
      */
     readonly usageRecorder?: UsageRecorder;
+    /** Shared resolver threaded from `assembleCoreRuntime`. */
+    readonly citationResolver: CitationResolver;
     /** Non-streaming chat — drives the agent loop + the post-step sub-agents. */
     readonly provider: AgentChat;
     /** Write-side embedder for the post-step vector index. */

package/dist/workflows/sandbox-step.js

@@ -193,6 +193,7 @@ export async function runSandboxStepBody(input, deps) {
         deadlineMs: () => stepDeadlineMs,
         lineageCollector,
         blockerHolder,
+        citationResolver: deps.citationResolver,
     });
     // Built over THIS agent's tools, not a shared table: a sandbox agent's roster
     // differs per agent type, and each tool describes its own calls.

package/dist/workflows/target-assessment/phase4-assemble.d.ts

@@ -1703,11 +1703,11 @@ export declare const Phase4OutputSchema: z.ZodObject<{
                                 dog: "dog";
                             }>;
                             rank: z.ZodEnum<{
+                                no_data: "no_data";
+                                absent: "absent";
                                 high: "high";
                                 medium: "medium";
                                 low: "low";
-                                absent: "absent";
-                                no_data: "no_data";
                                 not_loaded: "not_loaded";
                             }>;
                         }, z.core.$strip>>;

package/dist/workflows/target-assessment/schemas.d.ts

@@ -250,10 +250,10 @@ export declare const ExpressionMultiSpeciesBundleSchema: z.ZodObject<{
         tissues: z.ZodArray<z.ZodObject<{
             tissue: z.ZodString;
             rank: z.ZodEnum<{
+                absent: "absent";
                 high: "high";
                 medium: "medium";
                 low: "low";
-                absent: "absent";
             }>;
             expressionScore: z.ZodNullable<z.ZodNumber>;
         }, z.core.$strip>>;
@@ -669,10 +669,10 @@ export declare const Phase1BundleSchema: z.ZodObject<{
                     tissues: z.ZodArray<z.ZodObject<{
                         tissue: z.ZodString;
                         rank: z.ZodEnum<{
+                            absent: "absent";
                             high: "high";
                             medium: "medium";
                             low: "low";
-                            absent: "absent";
                         }>;
                         expressionScore: z.ZodNullable<z.ZodNumber>;
                     }, z.core.$strip>>;

package/dist/workflows/target-assessment/steps/phase2-aggregate.d.ts

@@ -336,10 +336,10 @@ export declare const Phase2BundleSchema: z.ZodObject<{
                         tissues: z.ZodArray<z.ZodObject<{
                             tissue: z.ZodString;
                             rank: z.ZodEnum<{
+                                absent: "absent";
                                 high: "high";
                                 medium: "medium";
                                 low: "low";
-                                absent: "absent";
                             }>;
                             expressionScore: z.ZodNullable<z.ZodNumber>;
                         }, z.core.$strip>>;

package/dist/workflows/target-assessment/steps/phase3-aggregate.d.ts

@@ -421,10 +421,10 @@ export declare const Phase3BundleSchema: z.ZodObject<{
                             tissues: z.ZodArray<z.ZodObject<{
                                 tissue: z.ZodString;
                                 rank: z.ZodEnum<{
+                                    absent: "absent";
                                     high: "high";
                                     medium: "medium";
                                     low: "low";
-                                    absent: "absent";
                                 }>;
                                 expressionScore: z.ZodNullable<z.ZodNumber>;
                             }, z.core.$strip>>;

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "@inflexa-ai/harness",
-    "version": "0.16.0",
+    "version": "0.17.0",
     "description": "Host-agnostic bioinformatics agent harness \u2014 hand-rolled agent loop, DBOS-durable workflows, sandboxed compute.",
     "license": "Apache-2.0",
     "type": "module",