@inflexa-ai/harness 0.45.1 → 0.46.0

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/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>;