@inflexa-ai/harness 0.45.1 → 0.46.2

package/dist/providers/embedding.d.ts

@@ -10,7 +10,7 @@ import type { Logger } from "../lib/logger.js";
 import { type SuspendOn } from "./errors.js";
 import type { ResolveRequestHeaders } from "./request-headers.js";
 import type { EmbeddingProvider, FetchLike } from "./types.js";
-export interface EmbeddingProviderDeps {
+export type EmbeddingProviderDeps = {
     /** Gateway base URL — all embedding traffic is routed through it. */
     readonly baseURL: string;
     /** API token presented to the gateway. */
@@ -34,5 +34,5 @@ export interface EmbeddingProviderDeps {
      * tests inject a fake to feed a recorded response.
      */
     readonly fetch?: FetchLike;
-}
+};
 export declare function createEmbeddingProvider(deps: EmbeddingProviderDeps): EmbeddingProvider;

package/dist/providers/embedding.js

@@ -27,7 +27,7 @@ export function createEmbeddingProvider(deps) {
         baseURL: deps.baseURL,
         apiKey: deps.token,
         maxRetries: 0,
-        ...(deps.fetch ? { fetch: deps.fetch } : {}),
+        fetch: deps.fetch,
     });
     const model = deps.model ?? DEFAULT_EMBEDDING_MODEL;
     const dimensions = deps.dimensions ?? DEFAULT_EMBEDDING_DIMENSIONS;

package/dist/providers/errors.d.ts

@@ -91,6 +91,26 @@ export type SuspendError = Extract<ProviderError, {
 export declare function findSuspendError(err: unknown): SuspendError | undefined;
 /** Find a `ProviderError` of any kind, by the walk of {@link findSuspendError}. */
 export declare function findProviderError(err: unknown): ProviderError | undefined;
+/**
+ * The class of a model call that failed after its retries. Each failure that
+ * time or a person can repair is named here, and nowhere else:
+ *
+ * - `outage`: a transient provider failure that outlived each retry.
+ * - `billing`: a status that the `suspendOn` map of the host names, with its reason.
+ * - `credential`: the endpoint refused the credential.
+ * - `other`: each other failure.
+ */
+export type ModelFailure = {
+    readonly kind: "outage";
+} | {
+    readonly kind: "billing";
+    readonly reason: string;
+} | {
+    readonly kind: "credential";
+} | {
+    readonly kind: "other";
+};
+export declare function modelFailureOf(err: unknown): ModelFailure;
 /**
  * Turn a caught SDK throwable into a `ProviderError` value. Routes through
  * `classifyProviderError` with the `suspendOn` map of the provider, so the
@@ -98,8 +118,8 @@ export declare function findProviderError(err: unknown): ProviderError | undefin
  * classification and a mapped status becomes a `suspend` error. `cause` is the
  * original throwable verbatim.
  *
- * Idempotent: `chatStream` throws a `ProviderError` value, which
- * `streaming-chat`'s `catch` re-wraps by calling this again. Returning an
+ * Idempotent: the retry envelope of the provider throws a `ProviderError`
+ * value, and a caller can wrap it again. Returning an
  * already-constructed `ProviderError` unchanged stops that second pass from
  * `String()`-ing the object (a `ProviderError` is not an `Error`) into a
  * `"[object Object]"` message that would bury the real inner one.

package/dist/providers/errors.js

@@ -17,7 +17,10 @@
  * which is a different remedy from every other non-retryable 4xx, so it is a
  * different kind.
  */
+import { errorMessageOf } from "../lib/thrown.js";
+import { textOf } from "../lib/unknown-text.js";
 import { redactSecrets } from "../input-sanitization.js";
+import { collapseWhitespace } from "../lib/text.js";
 /**
  * The sentinel that the request-timeout guard uses as an abort reason. The guard
  * arms a timer for each fetch attempt. On expiry the guard aborts the attempt
@@ -47,8 +50,11 @@ export const DEFAULT_SUSPEND_ON = { 402: "payment_required" };
 export function isProviderError(value) {
     if (typeof value !== "object" || value === null)
         return false;
-    const v = value;
-    return (v.type === "auth" || v.type === "suspend" || v.type === "provider") && typeof v.retryable === "boolean" && typeof v.message === "string";
+    if (!("type" in value && "retryable" in value && "message" in value))
+        return false;
+    return ((value.type === "auth" || value.type === "suspend" || value.type === "provider") &&
+        typeof value.retryable === "boolean" &&
+        typeof value.message === "string");
 }
 /**
  * Find a `suspend` error on a failure or on its `cause` chain. A step boundary
@@ -61,12 +67,25 @@ export function isProviderError(value) {
  */
 export function findSuspendError(err) {
     const asSuspend = (value) => (isProviderError(value) && value.type === "suspend" ? value : undefined);
-    return findInCauseChain(err, (link) => asSuspend(link) ?? (typeof link === "object" && link !== null ? asSuspend(link.value) : undefined));
+    return findInCauseChain(err, (link) => asSuspend(link) ?? ("value" in link ? asSuspend(link.value) : undefined));
 }
 /** Find a `ProviderError` of any kind, by the walk of {@link findSuspendError}. */
 export function findProviderError(err) {
     const asProviderError = (value) => (isProviderError(value) ? value : undefined);
-    return findInCauseChain(err, (link) => asProviderError(link) ?? (typeof link === "object" && link !== null ? asProviderError(link.value) : undefined));
+    return findInCauseChain(err, (link) => asProviderError(link) ?? ("value" in link ? asProviderError(link.value) : undefined));
+}
+export function modelFailureOf(err) {
+    const error = findProviderError(err);
+    switch (error?.type) {
+        case "suspend":
+            return { kind: "billing", reason: error.reason };
+        case "auth":
+            return { kind: "credential" };
+        case "provider":
+            return error.retryable ? { kind: "outage" } : { kind: "other" };
+        case undefined:
+            return { kind: "other" };
+    }
 }
 /**
  * Turn a caught SDK throwable into a `ProviderError` value. Routes through
@@ -75,8 +94,8 @@ export function findProviderError(err) {
  * classification and a mapped status becomes a `suspend` error. `cause` is the
  * original throwable verbatim.
  *
- * Idempotent: `chatStream` throws a `ProviderError` value, which
- * `streaming-chat`'s `catch` re-wraps by calling this again. Returning an
+ * Idempotent: the retry envelope of the provider throws a `ProviderError`
+ * value, and a caller can wrap it again. Returning an
  * already-constructed `ProviderError` unchanged stops that second pass from
  * `String()`-ing the object (a `ProviderError` is not an `Error`) into a
  * `"[object Object]"` message that would bury the real inner one.
@@ -94,12 +113,12 @@ export function toProviderError(e, workload, suspendOn = DEFAULT_SUSPEND_ON) {
         return {
             type: "provider",
             retryable: true,
-            message: `The provider sent no data for ${workload} within the request timeout of ${timeout.requestTimeoutMs} ms.`,
+            message: `The provider sent no data for ${workload} within the request timeout of ${timeout} ms.`,
             cause: e,
         };
     }
     const classified = classifyProviderError(e, suspendOn);
-    const detail = e instanceof Error ? e.message : String(e);
+    const detail = errorMessageOf(e) ?? textOf(e);
     if (classified.kind === "auth") {
         return {
             type: "auth",
@@ -165,10 +184,10 @@ const PROVIDER_BODY_EXCERPT_MAX_LEN = 120;
  * strings) and is safe on biological data, so a legitimate error body passes through intact.
  */
 function excerptResponseBody(body) {
-    const singleLine = redactSecrets(body).replace(/\s+/g, " ").trim();
+    const singleLine = collapseWhitespace(redactSecrets(body));
     // Slice by CODE POINT, not UTF-16 unit: a raw byte body can carry astral characters, and a plain
     // `.slice` could bisect a surrogate pair into a lone half that renders as U+FFFD.
-    const chars = [...singleLine];
+    const chars = Array.from(singleLine);
     return chars.length > PROVIDER_BODY_EXCERPT_MAX_LEN ? chars.slice(0, PROVIDER_BODY_EXCERPT_MAX_LEN - 1).join("") + "…" : singleLine;
 }
 /** Max links walked on the `cause` chain looking for a structured status. */
@@ -185,20 +204,41 @@ const CONNECTION_ERROR_CODES = new Set([
     "UND_ERR_HEADERS_TIMEOUT",
     "UND_ERR_SOCKET",
 ]);
-const CONNECTION_ERROR_PATTERN = /fetch failed|socket hang up|network error|connection (?:refused|reset|error|closed)|econnrefused|enotfound|etimedout|terminated/i;
+/** The transport-failure phrases of the fetch stack, as the providers write them; the compare lowercases the link message. */
+const CONNECTION_ERROR_PHRASES = [
+    "fetch failed",
+    "socket hang up",
+    "network error",
+    "connection refused",
+    "connection reset",
+    "connection error",
+    "connection closed",
+    "econnrefused",
+    "enotfound",
+    "etimedout",
+    "terminated",
+];
 /**
  * Walk the `cause` chain up to {@link MAX_CAUSE_HOPS} links, and return the first
  * result that `probe` gives. `probe` gives a value for a link that matches, or
  * `undefined` for a link that does not. The walk stops at the first match, at
- * the hop cap, or at the end of the chain.
+ * the hop cap, or at the end of the chain. Each probe receives a link that the
+ * walk verified to be an object, so the probe reads its fields through the `in`
+ * narrowing and no assertion restates the check.
  */
 function findInCauseChain(err, probe) {
     let cursor = err;
-    for (let i = 0; i < MAX_CAUSE_HOPS && cursor; i++) {
+    for (let i = 0; i < MAX_CAUSE_HOPS; i++) {
+        // A link of a cause chain is whatever a `throw` carried — most links are Error
+        // instances, whose own fields a record schema cannot reach — so the gate is the
+        // hand object check (a null-prototype thrown value fails `instanceof Object`),
+        // and each probe narrows the fields it reads.
+        if (cursor === null || typeof cursor !== "object")
+            return undefined;
         const found = probe(cursor);
         if (found !== undefined)
             return found;
-        cursor = cursor.cause;
+        cursor = "cause" in cursor ? cursor.cause : undefined;
     }
     return undefined;
 }
@@ -210,11 +250,10 @@ function findInCauseChain(err, probe) {
  */
 export function extractStatus(err) {
     return findInCauseChain(err, (link) => {
-        const e = link;
-        if (typeof e.status === "number")
-            return e.status;
-        if (typeof e.statusCode === "number")
-            return e.statusCode;
+        if ("status" in link && typeof link.status === "number")
+            return link.status;
+        if ("statusCode" in link && typeof link.statusCode === "number")
+            return link.statusCode;
         return undefined;
     });
 }
@@ -228,29 +267,27 @@ export function extractStatus(err) {
  * `— response body:` segment says less than no segment at all.
  */
 function extractResponseBody(err) {
-    let cursor = err;
-    for (let i = 0; i < MAX_CAUSE_HOPS && cursor; i++) {
-        const e = cursor;
-        if (typeof e.responseBody === "string" && e.responseBody.trim() !== "")
-            return e.responseBody;
-        cursor = e.cause;
-    }
-    return undefined;
+    return findInCauseChain(err, (link) => {
+        if ("responseBody" in link && typeof link.responseBody === "string" && link.responseBody.trim() !== "")
+            return link.responseBody;
+        return undefined;
+    });
 }
 /**
- * Walk the `cause` chain for the request-timeout sentinel. The guard aborts a
- * fetch with a `RequestTimeoutError`. The SDK carries the abort reason down the
- * `cause` chain, thus the sentinel can sit one or more hops down.
+ * Walk the `cause` chain for the request-timeout bound. The guard aborts a fetch
+ * with a `RequestTimeoutError`. The SDK carries the abort reason down the `cause`
+ * chain, thus the sentinel can sit one or more hops down. The bound rides the
+ * sentinel, so the walk returns it directly.
  */
 function findRequestTimeout(err) {
     return findInCauseChain(err, (link) => {
         if (link instanceof RequestTimeoutError)
-            return link;
-        // A duplicate class identity across a realm boundary fails `instanceof`,
-        // thus match the name and the field as a fallback.
-        const e = link;
-        if (e.name === "RequestTimeoutError" && typeof e.requestTimeoutMs === "number")
-            return link;
+            return link.requestTimeoutMs;
+        // A duplicate class identity across a realm boundary fails `instanceof`, thus match
+        // the name and the field as a fallback.
+        if ("name" in link && link.name === "RequestTimeoutError" && "requestTimeoutMs" in link && typeof link.requestTimeoutMs === "number") {
+            return link.requestTimeoutMs;
+        }
         return undefined;
     });
 }
@@ -267,22 +304,27 @@ const SDK_TIMEOUT_ERROR_NAME = "TimeoutError";
  * an abort reason down the `cause` chain, thus the reason can sit one or more
  * hops down.
  */
-function findSdkTimeout(err) {
-    return findInCauseChain(err, (link) => {
-        const e = link;
-        return e.name === SDK_TIMEOUT_ERROR_NAME ? link : undefined;
-    });
+/**
+ * Does the `cause` chain hold the timeout that the SDK raises? The `DOMException`
+ * carries no field of its own, thus the name is the one signal. The SDK carries
+ * an abort reason down the `cause` chain, thus the reason can sit one or more
+ * hops down.
+ */
+function hasSdkTimeout(err) {
+    return findInCauseChain(err, (link) => ("name" in link && link.name === SDK_TIMEOUT_ERROR_NAME ? true : undefined)) ?? false;
 }
 /** Does any link of the `cause` chain look like a transport-level failure? */
 function looksLikeConnectionError(err) {
     return (findInCauseChain(err, (link) => {
-        const e = link;
-        if (typeof e.code === "string" && CONNECTION_ERROR_CODES.has(e.code))
-            return true;
-        if (typeof e.name === "string" && /^APIConnection/.test(e.name))
+        if ("code" in link && typeof link.code === "string" && CONNECTION_ERROR_CODES.has(link.code))
             return true;
-        if (typeof e.message === "string" && CONNECTION_ERROR_PATTERN.test(e.message))
+        if ("name" in link && typeof link.name === "string" && link.name.startsWith("APIConnection"))
             return true;
+        if ("message" in link && typeof link.message === "string") {
+            const message = link.message.toLowerCase();
+            if (CONNECTION_ERROR_PHRASES.some((phrase) => message.includes(phrase)))
+                return true;
+        }
         return undefined;
     }) ?? false);
 }
@@ -302,11 +344,17 @@ export function classifyProviderError(e, suspendOn = DEFAULT_SUSPEND_ON) {
     // policy as a connection error. This runs before the status and the
     // connection paths, because a timeout carries no HTTP status, and it must not
     // fall to a non-retryable path.
-    if (findRequestTimeout(e) !== undefined || findSdkTimeout(e) !== undefined)
+    if (findRequestTimeout(e) !== undefined || hasSdkTimeout(e))
         return { kind: "provider", retryable: true };
-    const status = extractStatus(e);
-    if (status !== undefined && Object.hasOwn(suspendOn, status)) {
-        return { kind: "suspend", retryable: false, reason: suspendOn[status], status };
+    // A status below 400 is the status of a response that started well, and the failure came later, for example a
+    // stream that a reset connection broke. Thus only an error status classifies, and the rest falls to the
+    // connection check.
+    const found = extractStatus(e);
+    const status = found !== undefined && found >= 400 ? found : undefined;
+    if (status !== undefined) {
+        const reason = suspendOn[status];
+        if (reason !== undefined)
+            return { kind: "suspend", retryable: false, reason, status };
     }
     // `auth` is its own kind rather than a plain non-retryable 4xx because the
     // remedy is categorically different: the request was well-formed and the

package/dist/providers/prompt-cache.d.ts

@@ -2,7 +2,7 @@
  * Prompt-cache policy → provider wire options.
  *
  * This is the **only** place in the harness that names a vendor for caching.
- * Everything upstream — `PromptCachePolicy`, `ChatUsage`, `RunAgentOptions` —
+ * Everything upstream — `PromptCachePolicy`, `ChatUsage`, `LoopOptions` —
  * speaks the neutral harness concept; this module translates it once, at the
  * provider seam, so the loop never learns which vendor it is talking to.
  *
@@ -54,11 +54,11 @@
  * ## Cache defeaters — what silently kills the hit rate
  *
  * The cache keys on an *exact prefix*, so anything that perturbs the head of the
- * request invalidates everything after it. The wrap-up of `runAgent`, the
- * salvage of `runToTerminal`, and a step's summary and file-metadata
- * continuations extend one conversation under a tool mask, thus they keep its
- * prefix (`loop/run-agent.ts`, `loop/continue-agent.ts`). A tool choice that
- * forbids a call would defeat the cache — see the CAUTION on `ChatRequest.toolChoice`.
+ * request invalidates everything after it. The salvage of `runWithSalvage`, and
+ * a step's summary and file-metadata follow-up requests, extend one
+ * conversation under a tool mask, thus they keep its prefix
+ * (`loop/run-loop.ts`). A tool choice that forbids a call would defeat the
+ * cache, because `@ai-sdk/anthropic` removes the tools from such a request.
  *
  * `loadRecent` gives the view of the latest compaction marker
  * (`memory/conversation-view.ts`). A compaction moves the start of the view one
@@ -132,8 +132,8 @@ export declare const CONVERSATION_PROMPT_CACHE: PromptCachePolicy;
  * `cacheControl` has already been renamed once, and the provider still accepts
  * `cache_control` as its alias.
  *
- * CAUTION: this is the marker's VALUE, not its placement. Attaching it to a
- * `ChatRequest` emits the invisible top-level field the module header warns
+ * CAUTION: this is the marker's VALUE, not its placement. Attaching it to the
+ * options of a request emits the invisible top-level field the module header warns
  * about. Place it with {@link withSystemPromptBreakpoint} and
  * {@link withPromptCacheBreakpoint}.
  */

package/dist/providers/prompt-cache.js

@@ -2,7 +2,7 @@
  * Prompt-cache policy → provider wire options.
  *
  * This is the **only** place in the harness that names a vendor for caching.
- * Everything upstream — `PromptCachePolicy`, `ChatUsage`, `RunAgentOptions` —
+ * Everything upstream — `PromptCachePolicy`, `ChatUsage`, `LoopOptions` —
  * speaks the neutral harness concept; this module translates it once, at the
  * provider seam, so the loop never learns which vendor it is talking to.
  *
@@ -54,11 +54,11 @@
  * ## Cache defeaters — what silently kills the hit rate
  *
  * The cache keys on an *exact prefix*, so anything that perturbs the head of the
- * request invalidates everything after it. The wrap-up of `runAgent`, the
- * salvage of `runToTerminal`, and a step's summary and file-metadata
- * continuations extend one conversation under a tool mask, thus they keep its
- * prefix (`loop/run-agent.ts`, `loop/continue-agent.ts`). A tool choice that
- * forbids a call would defeat the cache — see the CAUTION on `ChatRequest.toolChoice`.
+ * request invalidates everything after it. The salvage of `runWithSalvage`, and
+ * a step's summary and file-metadata follow-up requests, extend one
+ * conversation under a tool mask, thus they keep its prefix
+ * (`loop/run-loop.ts`). A tool choice that forbids a call would defeat the
+ * cache, because `@ai-sdk/anthropic` removes the tools from such a request.
  *
  * `loadRecent` gives the view of the latest compaction marker
  * (`memory/conversation-view.ts`). A compaction moves the start of the view one
@@ -92,6 +92,7 @@
  * flat-zero read counter beside a non-zero write counter is still the signature
  * of an endpoint billing for writes and serving no reads.
  */
+import { parseUnknownRecord } from "../lib/unknown-containers.js";
 /**
  * The default policy: cache with the 5-minute TTL.
  *
@@ -130,8 +131,8 @@ export const CONVERSATION_PROMPT_CACHE = { ttl: "1h" };
  * `cacheControl` has already been renamed once, and the provider still accepts
  * `cache_control` as its alias.
  *
- * CAUTION: this is the marker's VALUE, not its placement. Attaching it to a
- * `ChatRequest` emits the invisible top-level field the module header warns
+ * CAUTION: this is the marker's VALUE, not its placement. Attaching it to the
+ * options of a request emits the invisible top-level field the module header warns
  * about. Place it with {@link withSystemPromptBreakpoint} and
  * {@link withPromptCacheBreakpoint}.
  */
@@ -188,9 +189,10 @@ function canHostBreakpoint(message) {
     if (!Array.isArray(content))
         return false;
     const last = content.at(-1);
-    if (typeof last !== "object" || last === null)
+    const part = parseUnknownRecord(last);
+    if (part === undefined)
         return false;
-    return last.type !== "reasoning";
+    return !("type" in part) || part["type"] !== "reasoning";
 }
 /** The index of the last message that can host the breakpoint, or `-1` when none can. */
 function lastHostIndex(messages) {
@@ -227,7 +229,7 @@ function withoutBreakpoint(message) {
             continue;
         const { [key]: _dropped, ...rest } = bag;
         if (Object.keys(rest).length === 0)
-            delete remaining[namespace];
+            Reflect.deleteProperty(remaining, namespace);
         else
             remaining[namespace] = rest;
     }

package/dist/providers/reasoning.d.ts

@@ -1,8 +1,8 @@
 /**
  * The reasoning depth of a call.
  *
- * The effort resolves in order: `ChatRequest.reasoning` (set only through
- * `RunAgentOptions.reasoning`), the provider configuration's `reasoning`, then
+ * The effort resolves in order: the effort of the run (`LoopOptions.reasoning`),
+ * the provider configuration's `reasoning`, then
  * {@link DEFAULT_REASONING}. Anthropic discards its message cache when the
  * top-level effort changes between calls.
  *

package/dist/providers/reasoning.js

@@ -1,8 +1,8 @@
 /**
  * The reasoning depth of a call.
  *
- * The effort resolves in order: `ChatRequest.reasoning` (set only through
- * `RunAgentOptions.reasoning`), the provider configuration's `reasoning`, then
+ * The effort resolves in order: the effort of the run (`LoopOptions.reasoning`),
+ * the provider configuration's `reasoning`, then
  * {@link DEFAULT_REASONING}. Anthropic discards its message cache when the
  * top-level effort changes between calls.
  *

package/dist/providers/request-headers.js

@@ -16,7 +16,16 @@ export function requestHeadersFor(hook, session) {
 }
 export function headersRefusalError(refusal, workload) {
     const message = `The request headers hook refused the model call for ${workload}: ${refusal.reason}`;
-    return refusal.kind === "suspended"
-        ? { type: "suspend", retryable: false, reason: refusal.reason, message }
-        : { type: "provider", retryable: false, message };
+    switch (refusal.kind) {
+        case "suspended":
+            return { type: "suspend", retryable: false, reason: refusal.reason, message };
+        case "credential":
+            return { type: "auth", retryable: false, message };
+        case "failed":
+            return { type: "provider", retryable: false, message };
+        default: {
+            const exhaustive = refusal;
+            return exhaustive;
+        }
+    }
 }