@inflexa-ai/harness 0.30.0 → 0.30.2

package/dist/index.d.ts

@@ -67,9 +67,9 @@ export { createConfiguredAiSdkProvider, DEFAULT_MAX_OUTPUT_TOKENS } from "./prov
 export type { AiSdkProviderConfig, ConfiguredAiSdkProviderDeps } from "./providers/ai-sdk.js";
 export { createEmbeddingProvider } from "./providers/embedding.js";
 export type { EmbeddingProviderDeps } from "./providers/embedding.js";
-export type { AgentChat, ChatProvider, EmbeddingProvider, ChatRequest, ChatResponse, ChatStreamEvent, ChatUsage, ModelMessage, PromptCachePolicy, ReasoningEffort, ReasoningPolicy, } from "./providers/types.js";
+export type { AgentChat, ChatProvider, EmbeddingProvider, ChatRequest, ChatResponse, ChatStreamEvent, ChatUsage, ModelMessage, PromptCachePolicy, ReasoningPolicy, } from "./providers/types.js";
 export { DEFAULT_PROMPT_CACHE, promptCacheProviderOptions } from "./providers/prompt-cache.js";
-export { DEFAULT_REASONING, reasoningProviderOptions } from "./providers/reasoning.js";
+export { DEFAULT_REASONING } from "./providers/reasoning.js";
 export { toProviderError, isProviderError } from "./providers/errors.js";
 export type { ProviderError } from "./providers/errors.js";
 export { createStreamingChat } from "./providers/streaming-chat.js";

package/dist/index.js

@@ -104,13 +104,15 @@ export { createEmbeddingProvider } from "./providers/embedding.js";
 // `"off"`; the `cortex.harness.agent.cache_*_tokens` metrics show which case a
 // deployment is actually in.
 export { DEFAULT_PROMPT_CACHE, promptCacheProviderOptions } from "./providers/prompt-cache.js";
-// Reasoning depth. `ReasoningPolicy` is the vendor-neutral directive for how
-// deep a model reasons; a composition root sets it per run through
-// `RunAgentOptions.reasoning`. It defaults to `DEFAULT_REASONING` — adaptive
-// thinking at the `xhigh` effort — because an agent loop drives tools over many
-// iterations, and a shallow turn there wastes more calls than the deeper turn
-// costs in tokens. A host on a model with no reasoning support passes `"off"`.
-export { DEFAULT_REASONING, reasoningProviderOptions } from "./providers/reasoning.js";
+// Reasoning depth. `ReasoningPolicy` is the vendor-neutral name for how deep a
+// model reasons; a composition root sets it per run through
+// `RunAgentOptions.reasoning`. It defaults to `DEFAULT_REASONING` — `xhigh` —
+// because an agent loop drives tools over many iterations, and a shallow turn
+// there wastes more calls than the deeper turn costs in tokens. The provider
+// package resolves the name for the model that it is bound to, thus a model
+// that accepts no `xhigh` gets the nearest name that it accepts. A host on a
+// model with no reasoning support passes `"provider-default"`.
+export { DEFAULT_REASONING } from "./providers/reasoning.js";
 // Provider error channel. `ProviderError` is the value `chat`/`embed` fail
 // with; `toProviderError` is its sole constructor. Exposed so an embedder
 // realizing its own `ChatProvider`/`EmbeddingProvider` fails with the exact

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

@@ -76,14 +76,15 @@ export interface RunAgentOptions {
     readonly promptCache?: PromptCachePolicy;
     /**
      * Reasoning policy for every LLM call this run makes. Defaults to
-     * `DEFAULT_REASONING` (adaptive thinking at `xhigh`) — an agent loop drives
-     * tools over many iterations, and a shallow turn there costs more in wasted
-     * calls than the deeper turn costs in tokens.
+     * `DEFAULT_REASONING` (`xhigh`) — an agent loop drives tools over many
+     * iterations, and a shallow turn there costs more in wasted calls than the
+     * deeper turn costs in tokens. The provider package resolves the name for
+     * the model that it is bound to.
      *
      * The policy lives here, on the run, rather than on the provider, for the
      * same reason that the cache policy does: a one-shot LLM call elsewhere has
      * its own depth needs and must not inherit the depth of a loop. A host on a
-     * model with no reasoning support passes `"off"`.
+     * model with no reasoning support passes `"provider-default"`.
      */
     readonly reasoning?: ReasoningPolicy;
     /**

package/dist/loop/run-agent.js

@@ -8,7 +8,7 @@ import { markInterruptedMessage, syntheticUserMessage } from "../memory/ai-sdk-m
 import { stripUnansweredToolCalls } from "../memory/tool-call-integrity.js";
 import { classifyProviderError } from "../providers/errors.js";
 import { DEFAULT_PROMPT_CACHE, promptCacheProviderOptions } from "../providers/prompt-cache.js";
-import { DEFAULT_REASONING, mergeProviderOptions, reasoningProviderOptions } from "../providers/reasoning.js";
+import { DEFAULT_REASONING } from "../providers/reasoning.js";
 import { resultStep } from "./run-step.js";
 import { AskRejectedError, UnavailableAsk } from "../tools/approval/contract.js";
 import { isToolError, readToolResultImages } from "../tools/define-tool.js";
@@ -85,7 +85,10 @@ export async function runAgent(agent, initial, session, opts) {
     // Resolved once, not per iteration: an identical options object across every
     // call is itself part of the cache contract — the request prefix has to be
     // byte-identical to be read back.
-    const providerOptions = mergeProviderOptions(promptCacheProviderOptions(opts.promptCache ?? DEFAULT_PROMPT_CACHE), reasoningProviderOptions(opts.reasoning ?? DEFAULT_REASONING));
+    const providerOptions = promptCacheProviderOptions(opts.promptCache ?? DEFAULT_PROMPT_CACHE);
+    // The depth is a neutral name, and the provider package resolves it for the
+    // model. A vendor key here would turn that resolution off.
+    const reasoning = opts.reasoning ?? DEFAULT_REASONING;
     const usage = {};
     // Exactly one record per completed run — never one per iteration. That bound is
     // what keeps the default level affordable for an agent that runs long; the
@@ -233,6 +236,7 @@ export async function runAgent(agent, initial, session, opts) {
             tools: toolDefs,
             ...(opts.toolChoice !== undefined ? { toolChoice: opts.toolChoice } : {}),
             providerOptions,
+            reasoning,
         };
         const llmStepName = formatStepName.llm(i);
         const reply = await resultStep(runStep)(llmStepName, () => provider.chat(request, session, signal));
@@ -343,7 +347,7 @@ export async function runAgent(agent, initial, session, opts) {
     // because it is the one call whose write is pure waste, and the
     // cache_write_tokens counter is what makes that waste visible.
     const wrapUpStepName = formatStepName.llm(agent.maxIterations);
-    const wrapUp = await resultStep(runStep)(wrapUpStepName, () => provider.chat({ system: agent.systemPrompt, messages, tools: {}, toolChoice: "none", providerOptions }, session, signal));
+    const wrapUp = await resultStep(runStep)(wrapUpStepName, () => provider.chat({ system: agent.systemPrompt, messages, tools: {}, toolChoice: "none", providerOptions, reasoning }, session, signal));
     accountForCall(wrapUp, wrapUpStepName);
     if (wrapUp.finishReason === "aborted") {
         // An abort during the tool-less wrap-up is still the user cutting the turn — the

package/dist/providers/ai-sdk.js

@@ -1,4 +1,4 @@
-import { generateText, streamText, wrapLanguageModel, } from "ai";
+import { streamText, wrapLanguageModel, } from "ai";
 import { createAnthropic } from "@ai-sdk/anthropic";
 import { createOpenAI } from "@ai-sdk/openai";
 import { createOpenAICompatible } from "@ai-sdk/openai-compatible";
@@ -255,10 +255,10 @@ function requestedModelIdOf(model) {
 }
 /**
  * Capture the served model id at the raw model boundary, because that is the
- * only place it is still distinguishable from the requested one: `generateText`
- * and `streamText` both coalesce an unreported response model id to the bound
- * model's own id, so reading `result.response.modelId` would silently republish
- * the requested id as an endpoint's claim. A middleware sees the provider's
+ * only place it is still distinguishable from the requested one: `streamText`
+ * coalesces an unreported response model id to the bound model's own id, so
+ * reading `result.response.modelId` would silently republish the requested id
+ * as an endpoint's claim. A middleware sees the provider's
  * result before that fallback applies, so "reported nothing" stays absent.
  *
  * Built per call, never per provider: one provider instance serves concurrent
@@ -303,16 +303,6 @@ function responseFromMessages(input) {
     }
     return { message, finishReason, rawFinishReason, usage, requestedModelId, servedModelId };
 }
-function responseFromGenerate(result, identity) {
-    return responseFromMessages({
-        messages: result.responseMessages,
-        fallbackText: result.text,
-        finishReason: result.finishReason,
-        rawFinishReason: result.rawFinishReason,
-        usage: result.usage,
-        ...identity,
-    });
-}
 /**
  * Drop empty text parts — and messages left with no content at all — before
  * the wire call. The Anthropic Messages API rejects any request containing an
@@ -356,9 +346,57 @@ async function pullNextDelta(iterator) {
             return { kind: "delta", text: part.text };
         if (part.type === "abort")
             return { kind: "aborted", reason: part.reason };
+        // The SDK reports a wire failure as a part, not as a rejection, and it
+        // then closes the stream. Skipping it would turn a failed call into an
+        // empty assistant turn that the loop reads as a real answer.
+        if (part.type === "error")
+            return { kind: "failed", error: part.error };
     }
     return { kind: "end" };
 }
+/**
+ * The HTTP status that each Anthropic stream error type stands for.
+ *
+ * A provider names a mid-stream failure in the payload, not in the status line:
+ * a stream that carries `overloaded_error` reports the condition that a 529
+ * names on the non-streaming wire. The classifier reads the status alone, thus
+ * the part has to reach it as an error that names one, or the same condition
+ * would classify one way on `chat` and another way on `chatStream`.
+ */
+const STREAM_ERROR_STATUS = {
+    invalid_request_error: 400,
+    authentication_error: 401,
+    permission_error: 403,
+    not_found_error: 404,
+    request_too_large: 413,
+    rate_limit_error: 429,
+    timeout_error: 408,
+    api_error: 500,
+    overloaded_error: 529,
+};
+/**
+ * The failure that an `error` part of the SDK stream stands for.
+ *
+ * The part carries whatever the provider put on the wire, and that is often a
+ * bare object rather than an `Error`. Left as it is, it reaches the message as
+ * `[object Object]` and reaches the classifier with no status at all.
+ */
+function streamPartFailure(error) {
+    if (error instanceof Error)
+        return error;
+    if (typeof error !== "object" || error === null)
+        return new Error(String(error));
+    const reported = error;
+    const type = typeof reported.type === "string" ? reported.type : undefined;
+    const message = typeof reported.message === "string" ? reported.message : undefined;
+    const failure = new Error(message ?? type ?? "The provider reported a stream error.", { cause: error });
+    const status = type === undefined ? undefined : STREAM_ERROR_STATUS[type];
+    // `extractStatus` walks the chain for this field, thus the named condition
+    // classifies the same way it would from a status line.
+    if (status !== undefined)
+        Object.assign(failure, { status });
+    return failure;
+}
 /**
  * The failure that an `abort` part of the SDK stream stands for.
  *
@@ -394,16 +432,46 @@ export function createAiSdkProvider(deps) {
     const requestTimeoutMs = deps.requestTimeoutMs;
     const requestedModelId = requestedModelIdOf(deps.model);
     routeSdkWarningsTo(logger);
+    /**
+     * Record a call that the envelope gave up on.
+     *
+     * The envelope reports one attempt at `debug`, thus a deployment that runs
+     * at `info` keeps no trace of a call that exhausted its retries: the reply
+     * carries the failure to the user and the operator sees nothing. This is the
+     * one record that names the outcome.
+     */
+    function logFailure(session, failure, thrown) {
+        logger.error("provider call failed", {
+            workload: workloadOf(session),
+            kind: failure.type,
+            retryable: failure.retryable,
+            ...logger.errorFields(thrown),
+        });
+    }
     function chat(req, session, signal) {
         const run = async () => {
             const retry = createRetry(signal, logger, maxRetries);
             const capture = captureServedModelId(deps.model);
             try {
-                const result = await retry(async () => {
+                const collected = await retry(async () => {
                     // Attribution headers are time-limited; resolving them inside the
                     // retried closure keeps them fresh across a multi-minute window.
                     const headers = await resolveBillingHeaders(deps.resolveBilling, session);
-                    return generateText({
+                    // The call streams on the wire and collapses below.
+                    //
+                    // A non-streaming turn sends no header until the model completes,
+                    // thus the `headersTimeout` of the host HTTP client bounds the whole
+                    // generation. No option of the SDK lifts that bound, because it sits
+                    // under the fetch. Node defaults the field to 300s, and a turn near
+                    // 18k output tokens reaches it, while `DEFAULT_MAX_OUTPUT_TOKENS`
+                    // asks for up to 64k. A cut turn then costs twice: the envelope
+                    // starts the same generation again from zero.
+                    //
+                    // Anthropic states the rule for its own SDKs: a large `max_tokens`
+                    // makes streaming necessary, to prevent an HTTP timeout. Thus a
+                    // ceiling this size streams whether or not a consumer wants the
+                    // deltas, and `chatStream` stays the seam that forwards them.
+                    const result = streamText({
                         model: capture.model,
                         system: req.system,
                         messages: sanitizeMessages(req.messages),
@@ -416,19 +484,53 @@ export function createAiSdkProvider(deps) {
                         maxRetries: 0,
                         headers,
                         abortSignal: signal,
-                        // No SDK timeout rides here. `chunkMs` bounds a stream only,
-                        // thus it is inert on this call. The fetch guard is the full
-                        // bound, because the headers of a non-streaming response arrive
-                        // when the model completes.
+                        // `firstChunkMs` bounds the wait for the first content chunk,
+                        // and `chunkMs` bounds each later gap. Thus each silent interval
+                        // carries the one configured bound, and a turn that writes
+                        // steadily runs as long as it needs.
+                        ...(requestTimeoutMs !== undefined ? { timeout: { firstChunkMs: requestTimeoutMs, chunkMs: requestTimeoutMs } } : {}),
                         providerOptions: req.providerOptions,
+                        reasoning: req.reasoning,
                     });
+                    // The drain sits inside the retried closure, thus a failure at any
+                    // point of the stream re-runs the whole attempt and the envelope
+                    // keeps its whole-call scope. No delta reaches a consumer here —
+                    // `chatStream` is the seam that forwards them.
+                    const iterator = result.fullStream[Symbol.asyncIterator]();
+                    let text = "";
+                    for (let pull = await pullNextDelta(iterator); pull.kind !== "end"; pull = await pullNextDelta(iterator)) {
+                        // A caller abort rides out as the reason of its own signal, thus
+                        // it stays a cancellation and reaches the caller as a throw.
+                        if (pull.kind === "aborted")
+                            throw abortedStreamFailure(signal, pull.reason, requestTimeoutMs);
+                        if (pull.kind === "failed")
+                            throw streamPartFailure(pull.error);
+                        text += pull.text;
+                    }
+                    // These promises settle only once the stream is fully drained, thus
+                    // the loop above must reach its end before this point.
+                    return {
+                        messages: await result.responseMessages,
+                        fallbackText: text,
+                        finishReason: await result.finishReason,
+                        rawFinishReason: await result.rawFinishReason,
+                        usage: await result.usage,
+                    };
                 });
-                return ok(responseFromGenerate(result, { requestedModelId, servedModelId: capture.servedModelId() }));
+                return ok(responseFromMessages({
+                    ...collected,
+                    requestedModelId,
+                    // Read after the drain: the metadata chunk that carries the
+                    // served id reaches the capture only as the stream is consumed.
+                    servedModelId: capture.servedModelId(),
+                }));
             }
             catch (e) {
                 if (isAbortError(e) || signal?.aborted)
                     throw e;
-                return err(toProviderError(unwrapForClassification(e), workloadOf(session)));
+                const failure = toProviderError(unwrapForClassification(e), workloadOf(session));
+                logFailure(session, failure, e);
+                return err(failure);
             }
         };
         return new ResultAsync(run());
@@ -467,6 +569,7 @@ export function createAiSdkProvider(deps) {
                     // thus it feeds neither bound.
                     ...(requestTimeoutMs !== undefined ? { timeout: { firstChunkMs: requestTimeoutMs, chunkMs: requestTimeoutMs } } : {}),
                     providerOptions: req.providerOptions,
+                    reasoning: req.reasoning,
                 });
                 const iterator = result.fullStream[Symbol.asyncIterator]();
                 const first = await pullNextDelta(iterator);
@@ -475,6 +578,8 @@ export function createAiSdkProvider(deps) {
                 // fresh window under the retry policy of a connection error.
                 if (first.kind === "aborted")
                     throw abortedStreamFailure(signal, first.reason, requestTimeoutMs);
+                if (first.kind === "failed")
+                    throw streamPartFailure(first.error);
                 if (first.kind === "end") {
                     // A doStream promise rejection — the shape a real connection
                     // failure takes — does NOT surface at this first pull: streamText
@@ -520,6 +625,8 @@ export function createAiSdkProvider(deps) {
                 // terminal `ProviderError` from the throwable.
                 if (pull.kind === "aborted")
                     throw abortedStreamFailure(signal, pull.reason, requestTimeoutMs);
+                if (pull.kind === "failed")
+                    throw streamPartFailure(pull.error);
                 text += pull.text;
                 yield { type: "text-delta", text: pull.text };
             }
@@ -539,7 +646,9 @@ export function createAiSdkProvider(deps) {
         catch (e) {
             if (isAbortError(e) || signal?.aborted)
                 throw e;
-            throw toProviderError(unwrapForClassification(e), workloadOf(session));
+            const failure = toProviderError(unwrapForClassification(e), workloadOf(session));
+            logFailure(session, failure, e);
+            throw failure;
         }
     }
     // The provider advertises the guard limit on its own instance, thus a
@@ -622,39 +731,6 @@ function withStoreDirective(model, store) {
         },
     });
 }
-/**
- * Mirror the neutral reasoning effort into the namespace of an
- * OpenAI-compatible connection.
- *
- * The compatible provider reads `providerOptions[<the name of the connection>]`
- * rather than `providerOptions.openai`, and it derives that namespace from the
- * first dot-separated segment of the name. The loop cannot write that key,
- * because only this seam knows the name. Thus the middleware copies
- * `reasoningEffort` across at request time. A value that the caller already set
- * on the namespace wins, and a request with no effort passes through untouched.
- */
-function withCompatibleReasoning(model, name) {
-    const namespace = name.split(".")[0]?.trim();
-    if (namespace === undefined || namespace === "")
-        return model;
-    return wrapLanguageModel({
-        model,
-        middleware: {
-            transformParams: async ({ params }) => {
-                const effort = params.providerOptions?.["openai"]?.["reasoningEffort"];
-                if (effort === undefined)
-                    return params;
-                return {
-                    ...params,
-                    providerOptions: {
-                        ...params.providerOptions,
-                        [namespace]: { reasoningEffort: effort, ...params.providerOptions?.[namespace] },
-                    },
-                };
-            },
-        },
-    });
-}
 /**
  * Realize an `AiSdkProviderConfig` into a `ChatProvider` bound to that config's
  * connection and model. The model is closed into the returned provider here (it
@@ -735,7 +811,9 @@ export function createConfiguredAiSdkProvider(deps) {
         fetch: effectiveFetch,
     });
     return createAiSdkProvider({
-        model: withCompatibleReasoning(provider.chatModel(config.model), config.name),
+        // The compatible package reads the neutral `reasoning` of the call, thus
+        // the seam needs no middleware to carry the depth into its namespace.
+        model: provider.chatModel(config.model),
         resolveBilling: deps.resolveBilling,
         capabilities: config.capabilities,
         logger: deps.logger,

package/dist/providers/reasoning.d.ts

@@ -1,35 +1,18 @@
 /**
- * Reasoning policy → provider wire options.
+ * The reasoning depth of a run.
  *
- * This is the **only** place in the harness that names a vendor for reasoning
- * depth. Everything upstream — `ReasoningPolicy` and `RunAgentOptions` — speaks
- * the neutral harness concept. This module translates it one time, at the
- * provider seam, thus the loop never learns which vendor it talks to. It is the
- * sibling of `prompt-cache.ts`, and it obeys the same rules.
+ * The harness states the depth one time, on `ChatRequest.reasoning`, with the
+ * neutral names of the AI SDK. It names no vendor key. Each provider package
+ * holds the table of what its own models accept, and it maps the neutral name
+ * onto the wire. The Anthropic package also selects adaptive thinking there.
  *
- * ## Why the emitted options are safe on every provider
+ * ## Why the harness names no vendor key
  *
- * `providerOptions` of the AI SDK is a namespaced bag. Each provider reads only
- * `providerOptions[<its own name>]`, and it ignores each other key. Thus the
- * `anthropic` namespace is inert on an OpenAI model, and the `openai` namespace
- * is inert on an Anthropic model. Neither one is an error.
- *
- * ## What each namespace does
- *
- * The Anthropic namespace carries two keys, because the vendor splits the
- * concept in two:
- *
- *  - `thinking: { type: "adaptive" }` says that the model reasons, and it lets
- *    the model choose the depth for each turn. A fixed `budgetTokens` is removed
- *    on the current models, and it returns a 400 there.
- *  - `effort` says how deep the model reasons and how much it spends in total.
- *    The vendor default is `high`.
- *
- * The OpenAI namespace carries one key, `reasoningEffort`, which takes the same
- * five values. An OpenAI-compatible endpoint reads the same key, but from a
- * namespace that carries the *name of the connection* rather than `openai`. The
- * provider seam mirrors the value into that namespace, because only the seam
- * knows the name (`providers/ai-sdk.ts`).
+ * The harness wrote `providerOptions.anthropic.effort` before. A value on that
+ * key turns the per-model table of the Anthropic package off, thus the raw name
+ * reached the wire. A model that accepts `high` but not `xhigh` answered 400.
+ * The neutral field has no such hazard, because the package resolves the name
+ * for the model that it is bound to.
  *
  * ## Where the policy belongs
  *
@@ -37,29 +20,16 @@
  * cache policy does. A one-shot LLM call elsewhere in the harness has its own
  * depth needs, and it must not inherit the depth of an agent loop.
  */
-import type { ProviderOptions, ReasoningPolicy } from "./types.js";
+import type { ReasoningPolicy } from "./types.js";
 /**
- * The default policy: adaptive thinking at the `xhigh` effort.
+ * The default policy: the deepest name of the neutral ladder.
  *
- * `xhigh` sits between `high` and `max`. It is the vendor recommendation for
- * coding and agentic work, and each agent of the harness drives tools over many
- * iterations. `max` costs more than the remaining quality is worth for a routine
- * turn, thus it is not the default. A host that wants a cheaper loop passes a
- * lower effort, and a host on a model with no reasoning support passes `"off"`.
- */
-export declare const DEFAULT_REASONING: ReasoningPolicy;
-/**
- * Translate a neutral reasoning policy into provider wire options.
+ * Each agent of the harness drives tools over many iterations. A shallow turn
+ * there wastes more calls than a deeper turn costs in tokens. The Anthropic
+ * package sends `xhigh` to a model that accepts it, and `max` to a model that
+ * does not. The OpenAI-compatible package sends the name as it is.
  *
- * Returns `undefined` for `"off"`, thus the caller can leave `providerOptions`
- * unset rather than send an empty bag.
+ * A host that wants a cheaper loop passes a lower name. A host on a model with
+ * no reasoning support passes `"provider-default"`.
  */
-export declare function reasoningProviderOptions(policy: ReasoningPolicy): ProviderOptions | undefined;
-/**
- * Merge two option bags one namespace at a time.
- *
- * A plain spread of the two bags drops a whole namespace when both sides carry
- * it, and the cache policy and the reasoning policy both write `anthropic`. The
- * right-hand bag wins for a key that both sides set.
- */
-export declare function mergeProviderOptions(left: ProviderOptions | undefined, right: ProviderOptions | undefined): ProviderOptions | undefined;
+export declare const DEFAULT_REASONING: ReasoningPolicy;

package/dist/providers/reasoning.js

@@ -1,35 +1,18 @@
 /**
- * Reasoning policy → provider wire options.
+ * The reasoning depth of a run.
  *
- * This is the **only** place in the harness that names a vendor for reasoning
- * depth. Everything upstream — `ReasoningPolicy` and `RunAgentOptions` — speaks
- * the neutral harness concept. This module translates it one time, at the
- * provider seam, thus the loop never learns which vendor it talks to. It is the
- * sibling of `prompt-cache.ts`, and it obeys the same rules.
+ * The harness states the depth one time, on `ChatRequest.reasoning`, with the
+ * neutral names of the AI SDK. It names no vendor key. Each provider package
+ * holds the table of what its own models accept, and it maps the neutral name
+ * onto the wire. The Anthropic package also selects adaptive thinking there.
  *
- * ## Why the emitted options are safe on every provider
+ * ## Why the harness names no vendor key
  *
- * `providerOptions` of the AI SDK is a namespaced bag. Each provider reads only
- * `providerOptions[<its own name>]`, and it ignores each other key. Thus the
- * `anthropic` namespace is inert on an OpenAI model, and the `openai` namespace
- * is inert on an Anthropic model. Neither one is an error.
- *
- * ## What each namespace does
- *
- * The Anthropic namespace carries two keys, because the vendor splits the
- * concept in two:
- *
- *  - `thinking: { type: "adaptive" }` says that the model reasons, and it lets
- *    the model choose the depth for each turn. A fixed `budgetTokens` is removed
- *    on the current models, and it returns a 400 there.
- *  - `effort` says how deep the model reasons and how much it spends in total.
- *    The vendor default is `high`.
- *
- * The OpenAI namespace carries one key, `reasoningEffort`, which takes the same
- * five values. An OpenAI-compatible endpoint reads the same key, but from a
- * namespace that carries the *name of the connection* rather than `openai`. The
- * provider seam mirrors the value into that namespace, because only the seam
- * knows the name (`providers/ai-sdk.ts`).
+ * The harness wrote `providerOptions.anthropic.effort` before. A value on that
+ * key turns the per-model table of the Anthropic package off, thus the raw name
+ * reached the wire. A model that accepts `high` but not `xhigh` answered 400.
+ * The neutral field has no such hazard, because the package resolves the name
+ * for the model that it is bound to.
  *
  * ## Where the policy belongs
  *
@@ -38,44 +21,14 @@
  * depth needs, and it must not inherit the depth of an agent loop.
  */
 /**
- * The default policy: adaptive thinking at the `xhigh` effort.
+ * The default policy: the deepest name of the neutral ladder.
  *
- * `xhigh` sits between `high` and `max`. It is the vendor recommendation for
- * coding and agentic work, and each agent of the harness drives tools over many
- * iterations. `max` costs more than the remaining quality is worth for a routine
- * turn, thus it is not the default. A host that wants a cheaper loop passes a
- * lower effort, and a host on a model with no reasoning support passes `"off"`.
- */
-export const DEFAULT_REASONING = { effort: "xhigh" };
-/**
- * Translate a neutral reasoning policy into provider wire options.
- *
- * Returns `undefined` for `"off"`, thus the caller can leave `providerOptions`
- * unset rather than send an empty bag.
- */
-export function reasoningProviderOptions(policy) {
-    if (policy === "off")
-        return undefined;
-    return {
-        anthropic: { effort: policy.effort, thinking: { type: "adaptive" } },
-        openai: { reasoningEffort: policy.effort },
-    };
-}
-/**
- * Merge two option bags one namespace at a time.
+ * Each agent of the harness drives tools over many iterations. A shallow turn
+ * there wastes more calls than a deeper turn costs in tokens. The Anthropic
+ * package sends `xhigh` to a model that accepts it, and `max` to a model that
+ * does not. The OpenAI-compatible package sends the name as it is.
  *
- * A plain spread of the two bags drops a whole namespace when both sides carry
- * it, and the cache policy and the reasoning policy both write `anthropic`. The
- * right-hand bag wins for a key that both sides set.
+ * A host that wants a cheaper loop passes a lower name. A host on a model with
+ * no reasoning support passes `"provider-default"`.
  */
-export function mergeProviderOptions(left, right) {
-    if (left === undefined)
-        return right;
-    if (right === undefined)
-        return left;
-    const merged = { ...left };
-    for (const [namespace, options] of Object.entries(right)) {
-        merged[namespace] = { ...merged[namespace], ...options };
-    }
-    return merged;
-}
+export const DEFAULT_REASONING = "xhigh";

package/dist/providers/types.d.ts

@@ -6,6 +6,7 @@
  * attribution is resolved lazily at the provider wire boundary.
  */
 import type { FinishReason, LanguageModel, ModelMessage, ToolSet } from "ai";
+import type { LanguageModelV4CallOptions } from "@ai-sdk/provider";
 import type { ProviderOptions } from "@ai-sdk/provider-utils";
 import type { ResultAsync } from "neverthrow";
 import type { AgentSession } from "../auth/types.js";
@@ -40,6 +41,11 @@ export interface ChatRequest {
         readonly toolName: string;
     };
     readonly providerOptions?: ProviderOptions;
+    /**
+     * How deep the model reasons on this call. Absent sends no directive, thus
+     * the model applies its own default. Refer to `ReasoningPolicy`.
+     */
+    readonly reasoning?: ReasoningPolicy;
 }
 /**
  * Vendor-neutral prompt-cache policy — a harness concept, not a vendor one.
@@ -57,17 +63,23 @@ export type PromptCachePolicy = {
 /**
  * How deep a model reasons, in harness-neutral names.
  *
- * `{ effort }` asks the provider for that reasoning depth, and `"off"` sends no
- * reasoning directive at all. The five values are the ladder that both vendor
- * families accept. A model with no reasoning support ignores the directive
- * rather than fails on it, thus the policy is a no-op for that model. Refer to
- * `./reasoning.ts`, the single place where the harness translates this into
- * vendor wire options.
+ * This is the `reasoning` call setting of the AI SDK, and the harness passes the
+ * value through without a change. Each provider package maps the name onto its
+ * own wire shape, and each one holds the table of what its models accept. The
+ * Anthropic package selects adaptive thinking with the matching `effort`, and it
+ * lowers a level that the model does not accept. The OpenAI-compatible package
+ * sends the name as `reasoning_effort`.
+ *
+ * `"provider-default"` sends no directive, thus the model applies its own
+ * default. `"none"` asks for no reasoning. The other names are the ladder from
+ * the shallowest depth to the deepest depth.
+ *
+ * CAUTION: never write `providerOptions.anthropic.effort` or
+ * `providerOptions.openai.reasoningEffort` in place of this field. A value on
+ * either key turns the per-model table off, and the raw name then reaches the
+ * wire. A model that does not accept that name answers 400.
  */
-export type ReasoningEffort = "low" | "medium" | "high" | "xhigh" | "max";
-export type ReasoningPolicy = {
-    readonly effort: ReasoningEffort;
-} | "off";
+export type ReasoningPolicy = NonNullable<LanguageModelV4CallOptions["reasoning"]>;
 /**
  * Token accounting for one chat call, in harness-neutral names.
  *

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "@inflexa-ai/harness",
-    "version": "0.30.0",
+    "version": "0.30.2",
     "description": "Host-agnostic bioinformatics agent harness — hand-rolled agent loop, DBOS-durable workflows, sandboxed compute.",
     "license": "Apache-2.0",
     "type": "module",