@inflexa-ai/harness 0.30.0 → 0.30.1

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

@@ -421,6 +421,7 @@ export function createAiSdkProvider(deps) {
                         // bound, because the headers of a non-streaming response arrive
                         // when the model completes.
                         providerOptions: req.providerOptions,
+                        reasoning: req.reasoning,
                     });
                 });
                 return ok(responseFromGenerate(result, { requestedModelId, servedModelId: capture.servedModelId() }));
@@ -467,6 +468,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);
@@ -622,39 +624,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 +704,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.1",
     "description": "Host-agnostic bioinformatics agent harness — hand-rolled agent loop, DBOS-durable workflows, sandboxed compute.",
     "license": "Apache-2.0",
     "type": "module",