@inflexa-ai/harness 0.45.1 → 0.46.2

package/dist/providers/types.d.ts

@@ -5,14 +5,15 @@
  * vendor-neutral interfaces. Every call carries an `AgentSession`; billing
  * attribution is resolved lazily at the provider wire boundary.
  */
-import type { FinishReason, LanguageModel, ModelMessage, SystemModelMessage, ToolSet } from "ai";
-import type { LanguageModelV4CallOptions } from "@ai-sdk/provider";
-import type { ProviderOptions } from "@ai-sdk/provider-utils";
+import type { TelemetryOptions } from "ai";
+import type { LanguageModelV4, LanguageModelV4CallOptions } from "@ai-sdk/provider";
 import type { ResultAsync } from "neverthrow";
 import type { AgentSession } from "../auth/types.js";
 import type { ProviderError } from "./errors.js";
-export type { FinishReason, LanguageModel, ModelMessage, ProviderOptions, ToolSet };
-export interface ProviderCapabilities {
+export type { FinishReason, LanguageModel, ModelMessage, ToolSet } from "ai";
+import type { ProviderOptions } from "@ai-sdk/provider-utils";
+export type { ProviderOptions } from "@ai-sdk/provider-utils";
+export type ProviderCapabilities = {
     readonly toolCalling: boolean;
     /**
      * Whether the wire can carry a picture inside a tool result. The loop moves a
@@ -23,48 +24,13 @@ export interface ProviderCapabilities {
      * see it. Absent means "cannot carry", never "unknown".
      */
     readonly imageToolResults?: boolean;
-    /**
-     * Whether the wire can carry a picture inside a user message. The loop uses
-     * this placement only when the tool result cannot carry the picture. The tool
-     * result then keeps its JSON text, and one user message after the tool message
-     * of the round carries the bytes. Absent means "cannot carry", never
-     * "unknown".
-     */
-    readonly imageUserMessages?: boolean;
     /**
      * The context window of the model in tokens, when the host knows it. A chat
      * thread then compacts at 80% of the window at the latest. Absent means "at
      * least the compaction budget of the agent", thus the budget stays as declared.
      */
     readonly contextWindow?: number;
-}
-/**
- * The request carries no free-form provider options. That would let a caller
- * set a vendor key that bypasses the provider's per-model table.
- */
-export interface ChatRequest {
-    /**
-     * The system prompt: a plain string, or a system message that carries the
-     * cache marker at its end (`withSystemPromptBreakpoint`).
-     */
-    readonly system: string | SystemModelMessage;
-    readonly messages: readonly ModelMessage[];
-    readonly tools: ToolSet;
-    /**
-     * A forced choice (`required`, or one named tool) is absent on purpose: some
-     * Claude models reject it with a 400, and the model is chosen at run time.
-     *
-     * CAUTION: `@ai-sdk/anthropic` strips the tools when this is `"none"`, and
-     * Anthropic drops its cache on any `tool_choice` change — taking a signed
-     * thinking block with it. Use a tool mask instead of sending `"none"`.
-     */
-    readonly toolChoice?: "auto" | "none";
-    /**
-     * How deep the model reasons. Absent, the effort falls back to the provider
-     * configuration's `reasoning`, then `DEFAULT_REASONING`.
-     */
-    readonly reasoning?: ReasoningPolicy;
-}
+};
 /**
  * Vendor-neutral prompt-cache policy — a harness concept, not a vendor one.
  *
@@ -116,74 +82,69 @@ export type ReasoningPolicy = NonNullable<LanguageModelV4CallOptions["reasoning"
  * totals without a cache breakdown, is legitimate. Absent means "not reported",
  * never "zero".
  */
-export interface ChatUsage {
+export type ChatUsage = {
     readonly inputTokens?: number;
     readonly outputTokens?: number;
     readonly cacheCreationInputTokens?: number;
     readonly cacheReadInputTokens?: number;
     readonly reasoningTokens?: number;
-}
-export interface ChatResponse {
-    readonly message: Extract<ModelMessage, {
-        role: "assistant";
-    }>;
-    /**
-     * The terminal reason for this reply. `"aborted"` is produced ONLY by the
-     * streaming wrapper (`createStreamingChat`), which resolves a client abort
-     * with the partial assistant text assembled from the deltas it already
-     * forwarded. The non-streaming `ChatProvider.chat` never yields `"aborted"`:
-     * it propagates a client abort as a throw, because durable workflow loops —
-     * the non-streaming provider's callers — record cancellation only when it
-     * surfaces as a thrown exception.
-     */
-    readonly finishReason: FinishReason | "aborted";
-    readonly rawFinishReason?: string;
-    readonly usage?: ChatUsage;
-    /**
-     * The id of the model this provider instance is bound to — what the caller
-     * asked for. Absent when the binding names no id.
-     */
-    readonly requestedModelId?: string;
-    /**
-     * The model id the provider itself reported as having answered. Absent
-     * whenever the provider reported none — it is NEVER filled in from
-     * `requestedModelId`, because a claim about which model answered is only
-     * worth anything when the endpoint actually made it.
-     *
-     * A value differing from `requestedModelId` is not an error: the pair exists
-     * so a consumer can observe an endpoint or proxy serving a different model
-     * version than the one configured. Treat the comparison as best-effort
-     * diagnostics, never as an invariant.
-     */
-    readonly servedModelId?: string;
-    /**
-     * The AI SDK's `LanguageModel.provider` id, for example `anthropic.messages`.
-     * Absent for a bare model-id string, which names no provider.
-     */
-    readonly provider?: string;
-}
+};
+/** A text delta of the reply that streams to a reader. */
 export type ChatStreamEvent = {
     readonly type: "text-delta";
     readonly text: string;
-} | {
-    readonly type: "done";
-    readonly response: ChatResponse;
 };
-export interface AgentChat {
+/** The facts of one run that bind a model: the session of its calls, its effort, and whether a reader sees its reply live. */
+export type ModelBinding = {
+    readonly session: AgentSession;
+    /** Absent: the effort of the provider configuration, then `DEFAULT_REASONING`. */
+    readonly reasoning?: ReasoningPolicy;
+    /**
+     * A reader sees the reply as it streams. A live call retries only before its first output part, and a
+     * call with no live reader takes its whole reply inside each attempt.
+     */
+    readonly live: boolean;
+    /** Called before the wait of each retry of a request inside the retry envelope. */
+    readonly onRetry?: (retry: ModelRetry) => void;
+};
+/** One retry of a model request inside the retry envelope of the provider. */
+export type ModelRetry = {
+    /** The id of the request. Each retry of one request carries the same id. */
+    readonly requestId: string;
+    /** The number of this retry, from 1. */
+    readonly attempt: number;
+    readonly maxRetries: number;
+    /** The wait before the next attempt, in milliseconds. */
+    readonly delayMs: number;
+    /** The HTTP error status of the failed attempt, 400 or higher. Absent for a failure with no error status. */
+    readonly status?: number;
+};
+/** The model of one run, under the retry envelope of its provider, and the call settings of each request. */
+export type BoundModel = {
+    readonly model: LanguageModelV4;
+    readonly settings: {
+        readonly maxOutputTokens?: number;
+        readonly reasoning: ReasoningPolicy;
+        readonly providerOptions?: ProviderOptions;
+    };
+    readonly telemetry: TelemetryOptions;
+};
+/**
+ * The model configuration of the harness: one model over one connection. The loop binds it for each run, and
+ * the AI SDK drives each request.
+ */
+export type ChatProvider = {
     readonly capabilities: ProviderCapabilities;
-    chat(req: ChatRequest, session: AgentSession, signal?: AbortSignal): ResultAsync<ChatResponse, ProviderError>;
-}
-export interface ChatProvider extends AgentChat {
-    chatStream(req: ChatRequest, session: AgentSession, signal?: AbortSignal): AsyncIterable<ChatStreamEvent>;
     /**
      * The request-timeout limit that this provider enforces, in milliseconds, or
      * absent when it enforces none. The value bounds each silent interval of a
      * request attempt: the wait until the response starts, and each gap between
-     * two content chunks of a stream. A consumer that scales a deadline reads this
+     * two content parts of a stream. A consumer that scales a deadline reads this
      * value from the provider instance, not from a harness constant.
      */
     readonly requestTimeoutMs?: number;
-}
+    bind(binding: ModelBinding): BoundModel;
+};
 /**
  * The effective deadline in milliseconds for a provider-bound operation.
  *
@@ -192,7 +153,7 @@ export interface ChatProvider extends AgentChat {
  * a configured request timeout can raise the floor. It cannot lower the floor.
  */
 export declare function effectiveDeadlineMs(provider: Pick<ChatProvider, "requestTimeoutMs">, floorMs: number, explicitMs?: number): number;
-export interface EmbeddingProvider {
+export type EmbeddingProvider = {
     /**
      * Width of every vector `embed` returns. The write-side index paths create
      * each per-analysis pgvector index at exactly this width (`ensureSearchIndex`),
@@ -202,5 +163,5 @@ export interface EmbeddingProvider {
      */
     readonly dimensions: number;
     embed(texts: readonly string[], session: AgentSession): ResultAsync<number[][], ProviderError>;
-}
+};
 export type FetchLike = (input: string | URL | Request, init?: RequestInit) => Promise<Response>;

package/dist/reference-data/catalog.d.ts

@@ -6,13 +6,6 @@ export declare const REFERENCE_DATA_CATALOG_VERSION: 1;
 export declare const ReferenceArtifactPathSchema: z.ZodString;
 /** Lowercase SHA-256 digest of one artifact's bytes. */
 export declare const ReferenceSha256Schema: z.ZodString;
-/**
- * Logical content format, independent of compression: a `.txt.gz` mapping table
- * is `tsv`, not `gz`. Agents pick a reader from this rather than guessing from
- * the extension, so it stays a free token instead of an enum — a new source must
- * remain cheap to add, and an unrecognized format degrades to "unknown reader"
- * rather than failing catalog validation.
- */
 export declare const ReferenceArtifactFormatSchema: z.ZodString;
 /**
  * One final file distributed for a reference dataset: a stable install-relative
@@ -35,12 +28,6 @@ export declare const ReferenceArtifactSchema: z.ZodObject<{
     format: z.ZodString;
     contents: z.ZodString;
 }, z.core.$strict>;
-/**
- * Common-name organism the dataset describes, lowercase (`human`, `mouse`, `rat`).
- * Omitted for species-agnostic or multi-species sources. This is the axis a wrong
- * choice is most silently wrong on — human regulons over mouse counts still run —
- * so it is a first-class field rather than something inferred from the id suffix.
- */
 export declare const ReferenceOrganismSchema: z.ZodString;
 /** Provenance and licensing information for one supported reference dataset. */
 export declare const ReferenceDatasetSchema: z.ZodObject<{
@@ -128,10 +115,10 @@ export type ReferenceInstallPlanDataset = ReferenceDataset & {
     readonly installPath: string;
 };
 /** Deterministic plan; every artifact carries the upstream URL it is fetched from. */
-export interface ReferenceInstallPlan {
+export type ReferenceInstallPlan = {
     readonly catalogVersion: typeof REFERENCE_DATA_CATALOG_VERSION;
     readonly datasets: readonly ReferenceInstallPlanDataset[];
-}
+};
 /** A requested dataset id was not present in the selected catalog. */
 export declare class UnknownReferenceDatasetError extends Error {
     readonly code: "unknown_reference_dataset";

package/dist/reference-data/catalog.js

@@ -1,10 +1,16 @@
 import { posix as posixPath } from "node:path";
 import { err, ok } from "neverthrow";
+import { presentGet } from "../lib/present.js";
+import { isUnknownArray } from "../lib/unknown-array.js";
+import { parseUnknownRecord } from "../lib/unknown-containers.js";
 import { z } from "zod";
 /** Schema version for the checked-in reference-data catalog. */
 export const REFERENCE_DATA_CATALOG_VERSION = 1;
+// oxlint-disable-next-line eslint-js/no-restricted-syntax -- a dataset id is lowercase segments joined by one separator; the shape is the stable-id rule.
 const SAFE_ID = /^[a-z0-9]+(?:[._-][a-z0-9]+)*$/;
+// oxlint-disable-next-line eslint-js/no-restricted-syntax -- a version is alphanumeric segments joined by one separator; the shape is the path-segment rule.
 const SAFE_VERSION = /^[A-Za-z0-9]+(?:[._-][A-Za-z0-9]+)*$/;
+// oxlint-disable-next-line eslint-js/no-restricted-syntax -- a lowercase SHA-256 digest is 64 hex digits, the fixed digest shape.
 const SHA256 = /^[a-f0-9]{64}$/;
 function isSafeRelativePath(value) {
     if (value.length === 0 || value.includes("\\") || value.startsWith("/"))
@@ -28,7 +34,9 @@ const ReferenceArtifactUrlSchema = z.url().refine((value) => value.startsWith("h
  * remain cheap to add, and an unrecognized format degrades to "unknown reader"
  * rather than failing catalog validation.
  */
-export const ReferenceArtifactFormatSchema = z.string().regex(/^[a-z0-9]+(?:[+-][a-z0-9]+)*$/, "Expected a lowercase format token");
+// oxlint-disable-next-line eslint-js/no-restricted-syntax -- a format token is lowercase segments joined by one plus sign, the free-token rule the reader table keys on.
+const FORMAT_TOKEN_RE = /^[a-z0-9]+(?:[+-][a-z0-9]+)*$/;
+export const ReferenceArtifactFormatSchema = z.string().regex(FORMAT_TOKEN_RE, "Expected a lowercase format token");
 /**
  * One final file distributed for a reference dataset: a stable install-relative
  * path and the third-party https URL it is fetched from. The catalog carries no
@@ -56,7 +64,9 @@ export const ReferenceArtifactSchema = z.strictObject({
  * choice is most silently wrong on — human regulons over mouse counts still run —
  * so it is a first-class field rather than something inferred from the id suffix.
  */
-export const ReferenceOrganismSchema = z.string().regex(/^[a-z][a-z0-9]*(?:[ -][a-z0-9]+)*$/, "Expected a lowercase organism common name");
+// oxlint-disable-next-line eslint-js/no-restricted-syntax -- an organism common name is lowercase words joined by a space or hyphen; the shape keeps the search axis one canonical form.
+const ORGANISM_NAME_RE = /^[a-z][a-z0-9]*(?:[ -][a-z0-9]+)*$/;
+export const ReferenceOrganismSchema = z.string().regex(ORGANISM_NAME_RE, "Expected a lowercase organism common name");
 /** Provenance and licensing information for one supported reference dataset. */
 export const ReferenceDatasetSchema = z.object({
     id: z.string().regex(SAFE_ID, "Expected a stable lowercase dataset id"),
@@ -109,12 +119,19 @@ export const ReferenceDataCatalogSchema = z
 export function referenceArtifactKey(dataset, artifact) {
     return `${dataset.id}/${dataset.version}/${artifact.path}`;
 }
+// The walk freezes the original container: a rebuild would freeze a copy and
+// leave the real value mutable. z.custom passes the value through on success, so
+// the check decides "record or array" without producing a second object.
+const FreezableContainer = z.custom((value) => isUnknownArray(value) || parseUnknownRecord(value) !== undefined);
 function deepFreeze(value) {
-    if (value && typeof value === "object" && !Object.isFrozen(value)) {
-        for (const nested of Object.values(value))
-            deepFreeze(nested);
-        Object.freeze(value);
-    }
+    const parsed = FreezableContainer.safeParse(value);
+    if (!parsed.success)
+        return value;
+    if (Object.isFrozen(parsed.data))
+        return value;
+    for (const nested of Object.values(parsed.data))
+        deepFreeze(nested);
+    Object.freeze(parsed.data);
     return value;
 }
 /**
@@ -2103,7 +2120,7 @@ export function resolveReferenceInstallPlanFromCatalogForTesting(datasetIds, cat
     return ok({
         catalogVersion: catalog.version,
         datasets: selectedIds.map((id) => {
-            const dataset = byId.get(id);
+            const dataset = presentGet(byId, id, "the selected dataset");
             return { ...dataset, installPath: `${dataset.id}/${dataset.version}` };
         }),
     });

package/dist/reference-data/receipt.d.ts

@@ -13,11 +13,11 @@ declare const ReferenceReceiptArtifactSchema: z.ZodObject<{
     sha256: z.ZodString;
 }, z.core.$strip>;
 /** The fields of a receipt that identify the installed content. */
-export interface ReferenceReceiptContent {
+export type ReferenceReceiptContent = {
     readonly datasetId: string;
     readonly datasetVersion: string;
     readonly artifacts: readonly ReferenceReceiptArtifact[];
-}
+};
 /**
  * The identity of the installed bytes, independent of the install time. Consumers outside the
  * harness recompute it, so the input bytes are a contract: the SHA-256 of the compact JSON array

package/dist/report-model/assert-rules.js

@@ -93,5 +93,5 @@ export function checkCitationAssertion(reference, expected, resolved) {
     if (expected === undefined || expected === resolved) {
         return undefined;
     }
-    return { reference, reason: "assertion-failed", detail: `expected ${String(expected)} but resolved citation ${resolved}` };
+    return { reference, reason: "assertion-failed", detail: `expected ${expected} but resolved citation ${resolved}` };
 }