@inflexa-ai/harness 0.45.0 → 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.0",
-    "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,28 +39,30 @@
         "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",
         "@kubernetes/client-node": "^1.4.0",
+        "@mozilla/readability": "^0.6.0",
         "@opentelemetry/api": "^1.9.1",
         "@opentelemetry/core": "^2.9.0",
         "@opentelemetry/exporter-metrics-otlp-http": "^0.219.0",
@@ -72,8 +74,9 @@
         "@opentelemetry/semantic-conventions": "^1.43.0",
         "@types/dockerode": "^3.3.47",
         "@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",
@@ -82,6 +85,7 @@
         "hyparquet": "^1.28.1",
         "js-tiktoken": "^1.0.21",
         "kysely": "^0.29.6",
+        "linkedom": "^0.18.14",
         "mime": "^4.1.0",
         "nanoid": "^5.1.16",
         "neverthrow": "^8.2.0",
@@ -90,6 +94,7 @@
         "pdf-parse": "^2.4.5",
         "pg": "^8.22.0",
         "puppeteer-core": "^23.11.1",
+        "turndown": "^7.2.4",
         "zod": "^4.4.3"
     },
     "overrides": {
@@ -100,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/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 };
-}

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

@@ -1,236 +0,0 @@
-import { type FinishReason } from "ai";
-import type { AgentSession } from "../auth/types.js";
-import type { UsageRecorder } from "../billing/usage-recorder.js";
-import type { Logger } from "../lib/logger.js";
-import { type CompactionPolicy } from "./compaction.js";
-import type { AgentChat, ChatRequest, ChatResponse, PromptCachePolicy, ReasoningPolicy } from "../providers/types.js";
-import { type AskApproval, type AskRequest } from "../tools/approval/contract.js";
-import { type AgentRunUsage } from "./metrics.js";
-import { type ToolBudget, type ToolMask } from "./tool-mask.js";
-import { type ToolOutputStore } from "./tool-output.js";
-import type { AgentDefinition, EmitFn, LoopMessage, RunStep } from "./types.js";
-export interface AgentFinish {
-    readonly reason: FinishReason | "aborted" | "max_iterations" | "denied";
-    /**
-     * The endpoint's own word for the stop, when the provider captured one —
-     * `reason` normalizes it (an Anthropic `refusal` becomes `content-filter`).
-     */
-    readonly rawFinishReason?: string;
-    readonly cappedOut: boolean;
-    readonly truncationRecoveries: number;
-    /**
-     * What this loop's own LLM calls reported, the forced wrap-up included.
-     * Absent when no call reported anything — never an all-zero figure.
-     */
-    readonly usage?: AgentRunUsage;
-    /**
-     * The whole turn's total, every descendant loop included. Present only on
-     * the loop that created the turn accumulator — the run whose options
-     * carried none, which is by construction the turn's root.
-     */
-    readonly turnUsage?: AgentRunUsage;
-}
-export interface RunAgentResult {
-    readonly messages: LoopMessage[];
-    readonly finish: AgentFinish;
-}
-/** A request that the provider refused for its content: the HTTP status and the text of the provider error. */
-export interface RequestRefusal {
-    readonly status: number;
-    readonly message: string;
-}
-/** The result of a segment. A segment that ends on a refusal of its request carries the refusal. */
-export interface SegmentResult extends RunAgentResult {
-    readonly refusal?: RequestRefusal;
-}
-/** The messages that the loop appended after the last call of the round sink. */
-export interface AgentRound {
-    readonly messages: readonly LoopMessage[];
-}
-export interface StepNameFormatter {
-    llm(iteration: number): string;
-    tool(toolName: string, toolUseId: string): string;
-}
-export declare const DEFAULT_STEP_NAME_FORMATTER: StepNameFormatter;
-export interface RunAgentOptions {
-    readonly provider: AgentChat;
-    readonly signal: AbortSignal;
-    readonly emit: EmitFn;
-    /**
-     * The round sink. The loop awaits it before each model request, at each exit, and before a throw.
-     * A durable loop passes no sink, because DBOS replays the loop body.
-     */
-    readonly onRound?: (round: AgentRound) => Promise<void>;
-    /**
-     * The compaction policy. Each request then sends the view of the transcript, and the loop compacts
-     * before a task request whose view passes the budget. A durable loop passes no policy, because
-     * `recordsAfter` reads the database outside a step.
-     */
-    readonly compaction?: CompactionPolicy;
-    /**
-     * The messages that open the turn of a chat thread: the user message and its context records. The loop appends
-     * them after the turn-start compaction, thus the conversation holds each message in the order that it was sent.
-     * Absent: `initial` holds the whole conversation.
-     */
-    readonly turnInput?: readonly LoopMessage[];
-    /**
-     * Per-turn user-approval seam threaded into every tool's `ToolContext` as
-     * `ctx.ask`. A conversation tool calls it to pause for an explicit user
-     * decision; the caller (the turn) wires the realization that surfaces the
-     * prompt and returns the reply. Omitted on non-interactive paths (workflow
-     * contexts, headless embedders): approval then resolves to the shipped
-     * deny-by-default `UnavailableAsk`, so a tool that asks where nothing can
-     * answer is denied rather than left waiting on a surface that never responds.
-     */
-    readonly ask?: (request: AskRequest) => Promise<AskApproval>;
-    readonly runStep: RunStep;
-    readonly formatStepName?: StepNameFormatter;
-    readonly isFatalLoopError?: (err: unknown) => boolean;
-    /**
-     * Tool choice for every request of this run: part of the prefix that the
-     * prompt cache and a signed thinking block bind to.
-     */
-    readonly toolChoice?: ChatRequest["toolChoice"];
-    /**
-     * Optional outcome predicate for loop-driving agents whose result is
-     * recorded by a tool into closure state. Checked immediately after each
-     * dispatch round, once every sibling tool result has been appended.
-     */
-    readonly resolved?: () => boolean;
-    /**
-     * Tools allowed to run per request. The full tool set stays declared either
-     * way, since it is part of the cache/thinking-block prefix.
-     */
-    readonly toolMask?: ToolMask;
-    /** Max calls per tool for this run; a call in the same round counts against the budget too. */
-    readonly toolBudget?: ToolBudget;
-    /**
-     * Prompt-cache policy for every LLM call this run makes. Defaults to
-     * `DEFAULT_PROMPT_CACHE` (5m) — an agent loop always re-sends its prefix, so
-     * it breaks even by the second iteration. A host whose endpoint ignores or
-     * charges badly for cache directives passes `"off"`.
-     *
-     * The policy lives here, on the run, rather than on the provider, precisely
-     * so it applies to loops and *not* to the one-shot LLM calls made elsewhere
-     * (report generation): those would pay the
-     * cache-write premium for a cache nothing ever reads back.
-     */
-    readonly promptCache?: PromptCachePolicy;
-    /**
-     * The reasoning effort for each LLM call of this run, the forced wrap-up
-     * included. Anthropic discards its message cache when the top-level
-     * effort changes, so the run must send the same value, or none, throughout.
-     */
-    readonly reasoning?: ReasoningPolicy;
-    /**
-     * Diagnostic sink for the run's own lifecycle. Optional because `runAgent` is
-     * called from tools, workflow bodies, and test rigs alike — silence is the
-     * correct behaviour for a caller that wires nothing, and the noop fallback
-     * gives it without every call site threading `?.`.
-     *
-     * Distinct from `emit`, which feeds a user-facing surface: every host filters
-     * sub-agent events off that surface by `callPath` depth, so a sub-agent's
-     * progress is emitted and then dropped. This is where it survives.
-     */
-    readonly logger?: Logger;
-    /**
-     * Per-call LLM usage-accounting seam. Omitted falls back to the no-op
-     * recorder. `record` is a notice: the loop does not wait for its result,
-     * and it logs the reason of an `err` when the result arrives.
-     */
-    readonly usageRecorder?: UsageRecorder;
-    /** Keeps the text of each cut tool result. A run with no store cuts, and it keeps nothing. */
-    readonly toolOutputStore?: ToolOutputStore;
-    /**
-     * The turn's usage accumulator, supplied by whatever ran this loop as part
-     * of a larger turn (a sub-agent-running tool passes `ctx.turnUsage`). A run
-     * that receives none creates its own and is therefore the turn's root: it
-     * alone reports `turnUsage` on its finish.
-     */
-    readonly turnUsage?: AgentRunUsage;
-    /**
-     * The id of the tool call this loop runs inside, supplied by a
-     * sub-agent-running tool from its `ctx.invocationId`. It is what separates
-     * two dispatches of the *same* sub-agent in one round — they share the run
-     * frame, the call path, and every loop-local step name — in the usage
-     * record key. The data profile gives the workflow id of its attempt,
-     * because each profile runs under the same constant frame. Absent for any
-     * other loop that is not nested inside a tool dispatch (a chat turn's
-     * root, a workflow step body, a background task).
-     */
-    readonly invocationId?: string;
-}
-/** A run that receives no turn accumulator is the turn's root. See `RunAgentOptions.turnUsage`. */
-export declare const isTurnRoot: (opts: RunAgentOptions) => boolean;
-export declare function runAgent(agent: AgentDefinition, initial: readonly LoopMessage[], session: AgentSession, opts: RunAgentOptions): Promise<RunAgentResult>;
-/** The harness request of the wrap-up at the iteration cap. */
-export declare const WRAP_UP_REQUEST = "You reached the limit of tool rounds for this run, thus no tool can run now. Answer in text with the results that you have.";
-/** The cap of wrap-up requests: one answer, and one more request after a refused call. */
-export declare const WRAP_UP_MAX_REQUESTS = 2;
-/** One stretch of model requests of a conversation, under one mask. */
-export interface LoopSegment {
-    /** The tools that can run for each request of the segment. Absent lets each declared tool run. */
-    readonly mask: ToolMask | undefined;
-    readonly maxRequests: number;
-    readonly stepNames: StepNameFormatter;
-    /** The `index` of the first request of the segment in its `iteration` events. */
-    readonly firstIndex: number;
-    /** A harness request that the segment appends, as a synthetic user message, before its first request. */
-    readonly requestText?: string;
-    /**
-     * The segment runs after the iteration cap: its requests do not count as
-     * iterations, and the last one always ends the run, whatever its reply.
-     */
-    readonly closesCappedRun?: boolean;
-    /** The loop compacts before a request of the segment whose view passes the budget of the policy. */
-    readonly checksBudget?: boolean;
-    /** A refusal of a request, a `provider` error with the status `400` or `413`, ends the segment with no new message. */
-    readonly endsOnRequestRefusal?: boolean;
-}
-/**
- * One conversation, open for its segments. Each segment extends the same
- * prefix (system prompt, tools, tool choice) as the one before it.
- */
-export interface OpenLoop {
-    /**
-     * Compact the conversation when the last request passed the turn-start budget, and then append the input of the
-     * turn. The result of the run when an abort ends the compaction, or `undefined` when the run continues.
-     */
-    startTurn(input: readonly LoopMessage[]): Promise<RunAgentResult | undefined>;
-    /** Run one segment: the result of the run when a reply ends it, or `"capped"` when the segment used its cap. */
-    runSegment(segment: LoopSegment): Promise<SegmentResult | "capped">;
-    /** End a run after its last segment used its cap. */
-    endCapped(): Promise<RunAgentResult>;
-}
-/**
- * Open the loop over one conversation. `metricAgentId` is the id that usage
- * and run metrics count under, which is not always `agent.id`.
- */
-export declare function openLoop(agent: AgentDefinition, initial: readonly LoopMessage[], session: AgentSession, opts: RunAgentOptions, metricAgentId: string): OpenLoop;
-/** What one completed LLM call is accounted under. */
-export interface ChatCallAccounting {
-    readonly session: AgentSession;
-    readonly agentId: string;
-    readonly callPath: readonly string[];
-    /**
-     * The deterministic name inside the record key, for example `llm-{n}` for
-     * a loop call or `adhoc-route` for a direct call.
-     */
-    readonly stepName: string;
-    /** The id of the tool call that makes the call, when the call runs inside a tool dispatch. */
-    readonly invocationId?: string;
-    readonly usageRecorder: UsageRecorder;
-    /** The sink that the notice helper logs the reason of a recorder `err` to. */
-    readonly logger: Logger;
-    /** The accumulators that the usage of the call folds into, for example the run total and the turn total. */
-    readonly rollups: readonly AgentRunUsage[];
-}
-/**
- * Called at the fold point, before any run-ending branch, so an aborted or
- * dead run is still accounted. Token counters grow inside the call's step
- * body, not here, because a replay re-delivers the stored reply to this
- * function too; the record re-sends under the same idempotency key, which an
- * upserting sink counts once.
- */
-export declare function accountForChatCall(reply: ChatResponse, call: ChatCallAccounting): void;
-export declare function finalText(messages: readonly LoopMessage[]): string;