@inflexa-ai/harness 0.45.1 → 0.46.0

package/dist/workspace/search-config.js

@@ -9,7 +9,7 @@ import { createVectorStore } from "../state/vector-store.js";
 import { unwrapOrThrow } from "../lib/result.js";
 /** Derive the vector index name for an analysis. */
 export function searchIndexName(resourceId) {
-    return `search_${resourceId.replace(/-/g, "_")}`;
+    return `search_${resourceId.replaceAll("-", "_")}`;
 }
 const _ensuredIndexes = new Set();
 /**

package/package.json

@@ -1,7 +1,7 @@
 {
     "name": "@inflexa-ai/harness",
-    "version": "0.45.1",
-    "description": "Host-agnostic bioinformatics agent harness — hand-rolled agent loop, DBOS-durable workflows, sandboxed compute.",
+    "version": "0.46.0",
+    "description": "Host-agnostic bioinformatics agent harness — an agent loop on the AI SDK, DBOS-durable workflows, sandboxed compute.",
     "license": "Apache-2.0",
     "type": "module",
     "main": "dist/index.js",
@@ -39,24 +39,25 @@
         "format": "prettier --write src/",
         "format:file": "prettier --write",
         "gallery:data": "bash scripts/gallery-data.sh",
-        "lint": "eslint .",
+        "lint": "bun --bun oxlint",
         "lint:python": "ruff check src/input-scan/decoder && ruff format --check src/input-scan/decoder",
         "prepare": "tsc -p tsconfig.build.json && node scripts/copy-assets.mjs",
         "prepublishOnly": "bun run build && bun run smoke",
         "smoke": "node scripts/smoke.mjs",
         "test:full": "bash scripts/test-full.sh",
         "test:python": "python3 -m pytest src/input-scan/decoder -q",
-        "typecheck": "tsc -p tsconfig.json --noEmit"
+        "typecheck": "inflexa-typecheck"
     },
     "dependencies": {
-        "@ai-sdk/anthropic": "^4.0.62",
-        "@ai-sdk/openai": "^4.0.74",
-        "@ai-sdk/openai-compatible": "^3.0.55",
-        "@ai-sdk/otel": "^1.0.113",
-        "@ai-sdk/provider": "^4.0.18",
-        "@ai-sdk/provider-utils": "5.0.47",
+        "@ai-sdk/anthropic": "^4.0.89",
+        "@ai-sdk/openai": "^4.0.103",
+        "@ai-sdk/openai-compatible": "^3.0.79",
+        "@ai-sdk/otel": "^1.0.154",
+        "@ai-sdk/provider": "^4.0.34",
+        "@ai-sdk/provider-utils": "5.0.69",
         "@anthropic-ai/sdk": "^0.116.0",
-        "@dbos-inc/dbos-sdk": "^4.23.6",
+        "@dbos-inc/dbos-sdk": "^5.3.0",
+        "@dbos-inc/vercel-ai": "0.5.4",
         "@fontsource-variable/space-grotesk": "5.1.1",
         "@fontsource/ibm-plex-mono": "5.1.1",
         "@inflexa-ai/tsprov": "0.6.0",
@@ -75,7 +76,7 @@
         "@types/pg": "^8.20.0",
         "@types/turndown": "^5.0.6",
         "ag-grid-community": "36.1.0",
-        "ai": "^7.0.113",
+        "ai": "^7.0.154",
         "cheerio": "^1.2.0",
         "dockerode": "^4.0.12",
         "echarts": "6.1.0",
@@ -104,26 +105,24 @@
         "uuid": "^11.1.1"
     },
     "devDependencies": {
-        "@ai-sdk/amazon-bedrock": "^5.0.93",
-        "@eslint/js": "^10.0.1",
+        "@ai-sdk/amazon-bedrock": "^5.0.125",
+        "@inflexa-ai/oxlint-plugin": "0.8.0",
+        "@inflexa-ai/typecheck": "0.8.0",
         "@types/bun": "latest",
+        "@types/json-schema": "^7.0.15",
         "@types/node": "^24.13.3",
         "@types/pdf-parse": "^1.1.5",
+        "@typescript/native": "npm:typescript@7.0.2",
         "csstree-validator": "^4.0.1",
-        "eslint": "^10.7.0",
-        "eslint-plugin-neverthrow": "^1.1.4",
-        "globals": "^17.7.0",
         "html-validate": "^11.6.2",
+        "oxlint": "1.85.0",
+        "oxlint-tsgolint": "7.0.2003",
         "prettier": "^3.9.5",
         "testcontainers": "^10.28.0",
-        "typescript": "^6.0.3",
-        "typescript-eslint": "^8.64.0"
+        "typescript": "^6.0.3"
     },
     "publishConfig": {
         "access": "public",
         "registry": "https://registry.npmjs.org"
-    },
-    "patchedDependencies": {
-        "eslint-plugin-neverthrow@1.1.4": "patches/eslint-plugin-neverthrow@1.1.4.patch"
     }
 }

package/dist/loop/call-guard.d.ts

@@ -1,50 +0,0 @@
-/**
- * The call guard: a bound on repeated tool calls inside one agent run.
- *
- * A model that treats a tool answer as a state to poll calls the same tool
- * with the same input again and again, or drifts through one query after
- * another, until the iteration cap or the wall clock ends the run. A frontier
- * model reads an "unavailable" answer once and continues; a smaller model
- * does not. The guard makes that difference a host decision: the third call
- * with an input the run already sent, the call past the budget of one tool,
- * or the call past the budget of the whole run, answers a tool error that
- * tells the model to continue with what it has. The service behind the tool never sees the refused call.
- *
- * The guard wraps a list of tools for ONE run. Build it where the tools of
- * the run are built, never at construction of the host, thus the counters
- * start at zero for every run. A terminal tool (one that ends the run) must
- * not be wrapped: a refusal there would strand the run.
- */
-import type { Tool } from "../tools/define-tool.js";
-export interface CallGuardPolicy {
-    /** The calls with one identical input that a run may make to one tool. The next one is refused. */
-    readonly identicalLimit: number;
-    /** The calls, with any input, that a run may make to one tool. The next one is refused. */
-    readonly perToolLimit: number;
-    /** The calls, with any input, that a run may make across every guarded tool. The next one is refused by every tool. */
-    readonly totalLimit: number;
-}
-/**
- * Two identical calls let a model confirm an answer once. Twelve calls of one
- * tool is above the largest count a frontier planner made in the Phase 0
- * campaign (six and a half calls per plan across ALL tools) and far below the
- * two hundred that a looping planner reached. Forty calls across every tool
- * bounds the round over the tools that stays under each per-tool budget: in
- * the 32-task campaign every submitted Sonnet plan but two needed fewer, and
- * the one plan that ran to the wall clock made 62.
- */
-export declare const DEFAULT_CALL_GUARD: CallGuardPolicy;
-/** A stable key for one input: the JSON text with the object keys sorted at every depth. */
-export declare function canonicalInputKey(input: unknown): string;
-export interface GuardedCallRefusal {
-    readonly tool: string;
-    readonly kind: "identical" | "budget" | "total";
-    readonly calls: number;
-}
-export interface CallGuardOptions {
-    readonly policy?: CallGuardPolicy;
-    /** Called on each refusal, for the log of the host. */
-    readonly onRefusal?: (refusal: GuardedCallRefusal) => void;
-}
-/** Wrap each tool so its `execute` obeys the policy for the life of the returned list. */
-export declare function guardRepeatedCalls(tools: readonly Tool[], options?: CallGuardOptions): Tool[];

package/dist/loop/call-guard.js

@@ -1,90 +0,0 @@
-/**
- * The call guard: a bound on repeated tool calls inside one agent run.
- *
- * A model that treats a tool answer as a state to poll calls the same tool
- * with the same input again and again, or drifts through one query after
- * another, until the iteration cap or the wall clock ends the run. A frontier
- * model reads an "unavailable" answer once and continues; a smaller model
- * does not. The guard makes that difference a host decision: the third call
- * with an input the run already sent, the call past the budget of one tool,
- * or the call past the budget of the whole run, answers a tool error that
- * tells the model to continue with what it has. The service behind the tool never sees the refused call.
- *
- * The guard wraps a list of tools for ONE run. Build it where the tools of
- * the run are built, never at construction of the host, thus the counters
- * start at zero for every run. A terminal tool (one that ends the run) must
- * not be wrapped: a refusal there would strand the run.
- */
-import { err } from "neverthrow";
-/**
- * Two identical calls let a model confirm an answer once. Twelve calls of one
- * tool is above the largest count a frontier planner made in the Phase 0
- * campaign (six and a half calls per plan across ALL tools) and far below the
- * two hundred that a looping planner reached. Forty calls across every tool
- * bounds the round over the tools that stays under each per-tool budget: in
- * the 32-task campaign every submitted Sonnet plan but two needed fewer, and
- * the one plan that ran to the wall clock made 62.
- */
-export const DEFAULT_CALL_GUARD = { identicalLimit: 2, perToolLimit: 12, totalLimit: 40 };
-/** A stable key for one input: the JSON text with the object keys sorted at every depth. */
-export function canonicalInputKey(input) {
-    return JSON.stringify(sortKeys(input));
-}
-function sortKeys(value) {
-    if (Array.isArray(value))
-        return value.map(sortKeys);
-    if (value !== null && typeof value === "object") {
-        const out = {};
-        for (const key of Object.keys(value).sort())
-            out[key] = sortKeys(value[key]);
-        return out;
-    }
-    return value;
-}
-/** Wrap each tool so its `execute` obeys the policy for the life of the returned list. */
-export function guardRepeatedCalls(tools, options = {}) {
-    const policy = options.policy ?? DEFAULT_CALL_GUARD;
-    let total = 0;
-    return tools.map((tool) => {
-        let calls = 0;
-        const byInput = new Map();
-        const guarded = {
-            ...tool,
-            ...(tool.describeCall ? { describeCall: tool.describeCall.bind(tool) } : {}),
-            ...(tool.describeResult ? { describeResult: tool.describeResult.bind(tool) } : {}),
-            async execute(input, ctx) {
-                calls += 1;
-                const key = canonicalInputKey(input);
-                const identical = (byInput.get(key) ?? 0) + 1;
-                byInput.set(key, identical);
-                if (identical > policy.identicalLimit) {
-                    options.onRefusal?.({ tool: tool.id, kind: "identical", calls: identical });
-                    return err({
-                        error: `This run already called ${tool.id} with this exact input ${identical - 1} times, and the answer does not change within a run. ` +
-                            "Use the answer you have and continue. If the answer was that a resource is absent, plan without it or ask for it; do not search again.",
-                        retryable: false,
-                    });
-                }
-                total += 1;
-                if (total > policy.totalLimit) {
-                    options.onRefusal?.({ tool: tool.id, kind: "total", calls: total });
-                    return err({
-                        error: `This run made ${policy.totalLimit} calls across its search tools, which is the search budget of one run. ` +
-                            "Submit the plan you have now. If a required resource is absent, ask for it; do not search again.",
-                        retryable: false,
-                    });
-                }
-                if (calls > policy.perToolLimit) {
-                    options.onRefusal?.({ tool: tool.id, kind: "budget", calls });
-                    return err({
-                        error: `This run made ${policy.perToolLimit} calls of ${tool.id}, which is the budget of one run for one tool. ` +
-                            "Continue with what you have. If a required resource is absent, ask for it; do not search again.",
-                        retryable: false,
-                    });
-                }
-                return tool.execute(input, ctx);
-            },
-        };
-        return guarded;
-    });
-}

package/dist/loop/continue-agent.d.ts

@@ -1,40 +0,0 @@
-/**
- * A signed thinking block is bound to the exact prefix of its request, and the
- * prompt cache keys on that same prefix.
- * A continuation must extend the conversation, never replay it under a new
- * system prompt or tool set.
- */
-import type { AgentSession } from "../auth/types.js";
-import { type AgentFinish, type RequestRefusal, type RunAgentOptions, type StepNameFormatter } from "./run-agent.js";
-import type { ToolMask } from "./tool-mask.js";
-import type { AgentDefinition, LoopMessage } from "./types.js";
-export interface ContinuationRequest {
-    /** Appended as a synthetic user message. */
-    readonly text: string;
-    /** The requests still declare every tool of the agent, even when masked. */
-    readonly mask: ToolMask;
-    /** The continuation runs no wrap-up at its cap. */
-    readonly maxRequests: number;
-    /** Prefixes each step name (`<namespace>:<name>`) so its cache key cannot match the conversation's own. */
-    readonly stepNamespace: string;
-    /**
-     * When set, metrics and token counts are attributed to this id instead of
-     * `agent.id`, through `forSubAgent`. Omitted, both stay the agent's own.
-     */
-    readonly accountingAgentId?: string;
-    /** A `provider` error with the status `400` or `413` ends the continuation with the finish reason `error`, and no throw. */
-    readonly endOnRequestRefusal?: boolean;
-}
-export interface ContinuationResult {
-    /** The new messages only, starting with the synthetic request. */
-    readonly messages: LoopMessage[];
-    readonly finish: AgentFinish;
-    /** The refusal that ended a continuation with `endOnRequestRefusal`. */
-    readonly refusal?: RequestRefusal;
-}
-export declare function namespacedStepNames(base: StepNameFormatter, namespace: string): StepNameFormatter;
-/**
- * `agent` and `opts` must match the conversation's own, since each request
- * extends its cached prefix. `conversation` itself is never changed.
- */
-export declare function continueAgent(agent: AgentDefinition, conversation: readonly LoopMessage[], request: ContinuationRequest, session: AgentSession, opts: RunAgentOptions): Promise<ContinuationResult>;

package/dist/loop/continue-agent.js

@@ -1,38 +0,0 @@
-/**
- * A signed thinking block is bound to the exact prefix of its request, and the
- * prompt cache keys on that same prefix.
- * A continuation must extend the conversation, never replay it under a new
- * system prompt or tool set.
- */
-import { forSubAgent } from "../auth/types.js";
-import { traceAgentRun } from "./genai-spans.js";
-import { DEFAULT_STEP_NAME_FORMATTER, isTurnRoot, openLoop, } from "./run-agent.js";
-export function namespacedStepNames(base, namespace) {
-    return {
-        llm: (i) => `${namespace}:${base.llm(i)}`,
-        tool: (name, id) => `${namespace}:${base.tool(name, id)}`,
-    };
-}
-/**
- * `agent` and `opts` must match the conversation's own, since each request
- * extends its cached prefix. `conversation` itself is never changed.
- */
-export function continueAgent(agent, conversation, request, session, opts) {
-    const accountingAgentId = request.accountingAgentId;
-    const runSession = accountingAgentId === undefined ? session : forSubAgent(session, accountingAgentId);
-    const metricAgentId = accountingAgentId ?? agent.id;
-    return traceAgentRun(metricAgentId, runSession, isTurnRoot(opts), async () => {
-        const loop = openLoop(agent, conversation, runSession, opts, metricAgentId);
-        const outcome = await loop.runSegment({
-            mask: request.mask,
-            maxRequests: request.maxRequests,
-            stepNames: namespacedStepNames(opts.formatStepName ?? DEFAULT_STEP_NAME_FORMATTER, request.stepNamespace),
-            firstIndex: 0,
-            requestText: request.text,
-            ...(request.endOnRequestRefusal === true ? { endsOnRequestRefusal: true } : {}),
-        });
-        const result = outcome === "capped" ? await loop.endCapped() : outcome;
-        const refusal = outcome === "capped" ? undefined : outcome.refusal;
-        return { messages: result.messages.slice(conversation.length), finish: result.finish, ...(refusal === undefined ? {} : { refusal }) };
-    });
-}

package/dist/loop/genai-spans.d.ts

@@ -1,47 +0,0 @@
-/**
- * OpenTelemetry GenAI spans for the agent loop: `invoke_agent` around a run of
- * `runAgent`, and `execute_tool` around each tool call that it dispatches. The AI
- * SDK traces the model calls (`providers/ai-sdk.ts`). It never sees the loop or
- * the tools, because the harness runs both itself.
- *
- * The root of a turn opens its own trace, and a link carries it back to the run.
- * A run lasts hours and writes tens of thousands of spans, thus one trace of a
- * whole run passes the size limit of the trace store and no reader can follow
- * it. `inflexa.run_id` holds the turns of one run together.
- *
- * An `execute_tool` span is ERROR when our code fails the call. A failure that a
- * tool returns as data, for example a sandbox command that exits non-zero, is
- * normal iteration of the agent, and its span stays OK.
- */
-import type { ToolCallPart } from "ai";
-import type { AgentSession } from "../auth/types.js";
-import type { ToolOutcome } from "./tool-outcome.js";
-interface AgentRun {
-    readonly finish: {
-        readonly reason: string;
-        readonly cappedOut: boolean;
-    };
-}
-/**
- * Run one agent loop under an `invoke_agent` span. A turn root starts a new
- * trace; a loop under a turn stays in the trace of that turn.
- */
-export declare function traceAgentRun<T extends AgentRun>(agentName: string, session: AgentSession, turnRoot: boolean, run: () => Promise<T>): Promise<T>;
-/** Run one tool call under an `execute_tool` span that records how the call ended. */
-export declare function traceToolCall<T>(call: Pick<ToolCallPart, "toolName" | "toolCallId">, run: () => Promise<T>, outcomeOf: (value: T) => ToolOutcome): Promise<T>;
-/**
- * Record an exception that a tool threw on the active `execute_tool` span.
- * `error.type` is the code of the error when it has one, else its name.
- */
-export declare function recordToolException(err: Error): void;
-/**
- * Label a tool failure that is not an exception on the active `execute_tool`
- * span. `message` is text that our tool wrote, never text from the model.
- */
-export declare function labelToolFailure(type: string, message?: string): void;
-/**
- * Label a tool call whose input failed validation on the active `execute_tool`
- * span. `issues` is the shape of the failure, with no value of the input.
- */
-export declare function labelToolValidationFailure(issues: readonly string[]): void;
-export {};

package/dist/loop/genai-spans.js

@@ -1,134 +0,0 @@
-/**
- * OpenTelemetry GenAI spans for the agent loop: `invoke_agent` around a run of
- * `runAgent`, and `execute_tool` around each tool call that it dispatches. The AI
- * SDK traces the model calls (`providers/ai-sdk.ts`). It never sees the loop or
- * the tools, because the harness runs both itself.
- *
- * The root of a turn opens its own trace, and a link carries it back to the run.
- * A run lasts hours and writes tens of thousands of spans, thus one trace of a
- * whole run passes the size limit of the trace store and no reader can follow
- * it. `inflexa.run_id` holds the turns of one run together.
- *
- * An `execute_tool` span is ERROR when our code fails the call. A failure that a
- * tool returns as data, for example a sandbox command that exits non-zero, is
- * normal iteration of the agent, and its span stays OK.
- */
-import { context, SpanStatusCode, trace, TraceFlags } from "@opentelemetry/api";
-import { isTracingSuppressed } from "@opentelemetry/core";
-/**
- * Run one agent loop under an `invoke_agent` span. A turn root starts a new
- * trace; a loop under a turn stays in the trace of that turn.
- */
-export function traceAgentRun(agentName, session, turnRoot, run) {
-    const attributes = {
-        "gen_ai.operation.name": "invoke_agent",
-        "gen_ai.agent.name": agentName,
-        ...conversationAttributes(session),
-        ...runFrameAttributes(session),
-    };
-    return withSpan(`invoke_agent ${agentName}`, turnRoot ? turnRootOptions(attributes) : { attributes }, async (span) => {
-        const result = await run();
-        span.setAttributes({ "gen_ai.response.finish_reasons": [result.finish.reason], "inflexa.agent.capped_out": result.finish.cappedOut });
-        return result;
-    });
-}
-/** Run one tool call under an `execute_tool` span that records how the call ended. */
-export function traceToolCall(call, run, outcomeOf) {
-    const attributes = { "gen_ai.operation.name": "execute_tool", "gen_ai.tool.name": call.toolName, "gen_ai.tool.call.id": call.toolCallId };
-    return withSpan(`execute_tool ${call.toolName}`, { attributes }, async (span) => {
-        const value = await run();
-        const outcome = outcomeOf(value);
-        span.setAttribute("inflexa.tool.outcome", outcome);
-        if (outcome === "error")
-            span.setStatus({ code: SpanStatusCode.ERROR });
-        return value;
-    });
-}
-/** The cap of `inflexa.tool.error`, in characters. */
-const TOOL_ERROR_MAX_CHARS = 1_000;
-/**
- * Record an exception that a tool threw on the active `execute_tool` span.
- * `error.type` is the code of the error when it has one, else its name.
- */
-export function recordToolException(err) {
-    const span = trace.getActiveSpan();
-    if (span === undefined)
-        return;
-    span.recordException(err);
-    span.setAttribute("error.type", errorTypeOf(err));
-}
-/**
- * Label a tool failure that is not an exception on the active `execute_tool`
- * span. `message` is text that our tool wrote, never text from the model.
- */
-export function labelToolFailure(type, message) {
-    const span = trace.getActiveSpan();
-    if (span === undefined)
-        return;
-    span.setAttribute("error.type", type);
-    if (message !== undefined)
-        span.setAttribute("inflexa.tool.error", message.slice(0, TOOL_ERROR_MAX_CHARS));
-}
-/**
- * Label a tool call whose input failed validation on the active `execute_tool`
- * span. `issues` is the shape of the failure, with no value of the input.
- */
-export function labelToolValidationFailure(issues) {
-    const span = trace.getActiveSpan();
-    if (span === undefined)
-        return;
-    span.setAttributes({ "error.type": "validation", "inflexa.tool.validation.issues": [...issues] });
-}
-function errorTypeOf(err) {
-    const code = "code" in err ? err.code : undefined;
-    if ((typeof code === "string" && code !== "") || typeof code === "number")
-        return String(code);
-    return err.name === "" ? "_OTHER" : err.name;
-}
-/**
- * The options of a turn root. `root: true` drops the parent before the sampler
- * runs, thus the sampler takes its root branch and a decision from above is
- * lost. A turn under suppressed tracing, or under a trace that is not sampled
- * (an untraced workflow), therefore keeps its parent and stays unrecorded.
- */
-function turnRootOptions(attributes) {
-    const active = context.active();
-    if (isTracingSuppressed(active))
-        return { attributes };
-    const ambient = trace.getSpanContext(active);
-    if (ambient === undefined || !trace.isSpanContextValid(ambient))
-        return { root: true, attributes };
-    if ((ambient.traceFlags & TraceFlags.SAMPLED) === 0)
-        return { attributes };
-    // The span that started the turn: the workflow span of the run, or the request span.
-    return { root: true, links: [{ context: ambient, attributes: { "inflexa.link.kind": "caller" } }], attributes };
-}
-function withSpan(name, options, run) {
-    return trace.getTracer("@inflexa-ai/harness").startActiveSpan(name, options, async (span) => {
-        try {
-            return await run(span);
-        }
-        catch (err) {
-            // A cancellation is the caller's decision, not a failure.
-            const cancelled = err instanceof Error && err.name === "AbortError";
-            if (!cancelled) {
-                span.setStatus({ code: SpanStatusCode.ERROR });
-                if (err instanceof Error)
-                    span.recordException(err);
-            }
-            throw err;
-        }
-        finally {
-            span.end();
-        }
-    });
-}
-function runFrameAttributes({ runFrame }) {
-    if (runFrame === undefined)
-        return {};
-    return { "inflexa.run_id": runFrame.runId, ...(runFrame.stepId === undefined ? {} : { "inflexa.step_id": runFrame.stepId }) };
-}
-/** The thread is the conversation. The analysis is not: it holds many threads. */
-function conversationAttributes({ scope }) {
-    return scope.threadId === undefined ? {} : { "gen_ai.conversation.id": scope.threadId };
-}