@stigmer/runner 3.38.2 → 3.39.0

package/src/activities/execute-deep-agent/turn-setup.ts

@@ -40,6 +40,8 @@ import type { BaseCheckpointSaver } from "@langchain/langgraph-checkpoint";
 import type { DynamicStructuredTool } from "@langchain/core/tools";
 import type { Command } from "@langchain/langgraph";
 import { createDeepAgent } from "deepagents";
+import { providerStrategy } from "langchain";
+import { transformJSONSchema } from "@anthropic-ai/sdk/lib/transform-json-schema";
 import { InteractionMode } from "@stigmer/protos/ai/stigmer/agentic/agentexecution/v1/enum_pb";
 
 import type { Config } from "../../config.js";
@@ -60,8 +62,9 @@ import { createThinkTool, createWebFetchTool, resolveGuardPosture } from "../../
 import { deriveExecutionFingerprintKey } from "../../shared/approval-fingerprint.js";
 import { getRunnerHitlMasterSecret } from "../../shared/fingerprint-secret.js";
 import { getModelPricing, ensureLoaded as ensurePricingLoaded, type ModelPricing } from "../../shared/model-pricing.js";
-import { getDefaultModel } from "../../shared/model-registry.js";
+import { getDefaultModel, getNativeRequestProfile } from "../../shared/model-registry.js";
 import { buildChatModel } from "../../shared/model-client.js";
+import { graphThinks, toAnthropicThinking } from "../../shared/thinking-mode.js";
 import { isUnattendedApprovalMode, type MergedToolPolicy } from "../../shared/approval-policy.js";
 import type { ToolApprovalCategory } from "../../shared/tool-kind.js";
 import { alsoAvailableSkillsNote, selectSkillsForPrompt, visionPromptInfoOf } from "../../shared/prompt-sections.js";
@@ -75,7 +78,7 @@ import { mountPlatformRoute } from "./platform-route.js";
 import { resolveResumeInput, type GraphStateSnapshot } from "./hitl.js";
 import { buildEnhancedSystemPrompt, composeUserMessage, renderSkillsSection } from "./prompt-builder.js";
 import { buildShellEnv } from "./shell-env.js";
-import { modelHasNativeThinking, transformAndCompileSubagents } from "./subagent-transformer.js";
+import { transformAndCompileSubagents } from "./subagent-transformer.js";
 import { createTodoListMiddleware } from "./todo-list.js";
 
 /**
@@ -90,6 +93,14 @@ export type DeepAgentAdapterConfig = Pick<
   "checkpointerType" | "checkpointerProxyEndpoint" | "stigmerTokenRef" | "proxyEndpoint" | "mode"
 >;
 
+/**
+ * A JSON object schema, the shape langchain's provider strategy takes for a
+ * plain schema (its own type for it is not exported). An execution's
+ * structured output schema is an object schema; the SDK's transform keeps
+ * its root `type`.
+ */
+type ObjectJsonSchema = { type: "object"; [key: string]: unknown };
+
 /** The deepagents graph as this module holds it; deepagents exports no stable type for the compiled agent. */
 // eslint-disable-next-line @typescript-eslint/no-explicit-any
 export type AgentGraph = any;
@@ -129,7 +140,7 @@ export interface DeepAgentEngine {
   readonly graph: AgentGraph;
   readonly checkpointer: BaseCheckpointSaver;
   readonly langgraphConfig: Record<string, unknown>;
-  /** The registry id the turn runs on (pricing, the thinking heuristic, sub-agent inheritance key on it). */
+  /** The registry id the turn runs on (pricing and sub-agent inheritance key on it). */
   readonly modelName: string;
   readonly pricing: ModelPricing;
   readonly gate: DeepAgentGateState;
@@ -310,9 +321,10 @@ export function composeSystemPrompt(input: TurnInput, recalledMemories: Recalled
  * Build the engine: the model, the middleware stack with the gate, the
  * tools, the compiled sub-agents, the system prompt and `createDeepAgent`.
  *
- * The service tier resolved ONCE by the runtime rides every model this
- * execution constructs — the primary AND the sub-agent factory — so the
- * provider account's default can never pick the price of any turn (#361).
+ * The service tier and the thinking mode resolved ONCE by the runtime ride
+ * every model this execution constructs — the primary AND the sub-agent
+ * factory — so the provider account's default can never pick the price of
+ * any turn (#361), and every graph thinks in its own model's form.
  * `max_tool_rounds` resolves to one recursion limit that feeds BOTH the hard
  * stop on the invoke config and the budget middleware's ~80% advisory, so
  * the warning and the enforcement can never disagree.
@@ -341,25 +353,45 @@ export async function buildEngine(
   const primaryDir = input.workspace.primaryDir;
 
   // The model. Resolution to the provider API id happens inside
-  // buildChatModel; modelName stays the registry id for pricing, the
-  // native-thinking heuristic, and sub-agent inheritance. The credential is
-  // read from the ref at build, once per turn: a LangChain client carries
-  // its headers for its life, so this is the freshest a turn's model can be.
+  // buildChatModel; modelName stays the registry id for pricing and
+  // sub-agent inheritance. The credential is read from the ref at build,
+  // once per turn: a LangChain client carries its headers for its life, so
+  // this is the freshest a turn's model can be.
   //
-  // No temperature: current Anthropic models refuse one other than their
-  // default (claude-opus-4.7 and later and claude-fable-5 inside
-  // @langchain/anthropic, before any request; claude-sonnet-5 at the
-  // provider), and the Cursor harness sends none (stigmer/stigmer#1341).
-  const buildModelFor = async (name: string) =>
-    (await buildChatModel({
+  // What the request tells the provider about a model comes from the
+  // model's native registry row, never from a model name or a library's
+  // table, and is read here, the one place the execution's choices meet the
+  // row. The same factory builds every sub-agent's model, so each graph
+  // follows the row of the model it runs on:
+  // - no temperature: current Anthropic models refuse one other than their
+  //   default, and the Cursor harness sends none (stigmer/stigmer#1341);
+  // - the row's output ceiling, where LangChain's per-model default falls to
+  //   4096 on models its table does not know (stigmer/stigmer#1343), and
+  //   streaming on every call because the SDK refuses a non-streaming
+  //   request at that ceiling;
+  // - the execution's thinking mode in the form the row declares
+  //   (thinking-mode.ts toAnthropicThinking).
+  // A model with no native row (an unreachable registry) keeps the library
+  // defaults and sends no thinking parameter, as before.
+  const buildModelFor = async (name: string) => {
+    const profile = await getNativeRequestProfile(name);
+    return (await buildChatModel({
       modelName: name,
       proxyEndpoint: config.proxyEndpoint ?? undefined,
       stigmerToken: config.stigmerTokenRef.current ?? undefined,
       headerScope: { executionId },
       serviceTier: input.model.serviceTier,
       temperature: null,
+      maxTokens: profile?.maxOutputTokens,
+      streaming: true,
+      thinking: toAnthropicThinking(input.model.thinkingMode, profile?.thinking),
     })).model;
+  };
   const model = await buildModelFor(modelName);
+  // Whether this graph reasons natively, derived from the same mapping the
+  // request carries: it decides the `think` tool and the structured-output
+  // strategy below, so neither can disagree with the wire.
+  const parentThinks = graphThinks(input.model.thinkingMode, (await getNativeRequestProfile(modelName))?.thinking);
   sink.setupTiming.mark("build_model");
 
   await ensurePricingLoaded();
@@ -426,7 +458,13 @@ export async function buildEngine(
   // Cursor harness); its URL guard posture — strict on managed cloud runners,
   // relaxed on user-owned machines — is derived from the runner mode.
   const webFetchPosture = resolveGuardPosture(config.mode);
-  const graphTools = [...tools.mcpTools, createThinkTool(), createWebFetchTool({ posture: webFetchPosture })];
+  // `think` is a reasoning aid for a graph that does not reason natively;
+  // a graph that thinks has no use for it.
+  const graphTools = [
+    ...tools.mcpTools,
+    ...(parentThinks ? [] : [createThinkTool()]),
+    createWebFetchTool({ posture: webFetchPosture }),
+  ];
 
   await sink.reportProgress("Configuring sub-agents…");
   const compiledSubagents = await transformAndCompileSubagents({
@@ -441,7 +479,8 @@ export async function buildEngine(
     // to the SAME per-turn observer as the parent (Session 26, DD-19).
     casObserver: workspace.casObserver,
     parentModelName: modelName,
-    parentHasNativeThinking: modelHasNativeThinking(modelName),
+    parentThinks,
+    thinkingMode: input.model.thinkingMode,
     webFetchPosture,
     costAdvisory: costAdvisory ?? undefined,
     modelFactory: buildModelFor,
@@ -456,8 +495,20 @@ export async function buildEngine(
   // status the first time it is pulled, before this turn's first persist.
   const systemPrompt = composeSystemPrompt(input, await input.standing.selectRecalledMemories());
 
+  // Structured output takes one of langchain's two strategies, chosen here
+  // explicitly. A graph that thinks uses the provider strategy: Anthropic's
+  // own JSON output (`output_config.format`), which forces no tool, because
+  // forced tool use and thinking do not combine on every platform and
+  // model. Its schema goes through the SDK's own transform (the one
+  // @langchain/anthropic's withStructuredOutput applies): Anthropic accepts
+  // only closed objects, and the runner's zod keeps them open. A graph that
+  // does not think keeps the tool strategy, the raw zod, unchanged.
   const outputSchema = input.structuredOutputSchema;
-  const responseFormat = outputSchema ? jsonSchemaToZod(outputSchema) : undefined;
+  const responseFormat = outputSchema === undefined
+    ? undefined
+    : parentThinks
+      ? providerStrategy({ schema: transformJSONSchema(outputSchema) as ObjectJsonSchema })
+      : jsonSchemaToZod(outputSchema);
 
   // File capture point: the CAS-observing backend — git-tracked edits flow to
   // disk (the boundary's git diff is authoritative) and the shared observer

package/src/shared/__tests__/model-client-sampling.test.ts

@@ -5,12 +5,16 @@
  * validation is what failed every native turn on claude-opus-4.7,
  * claude-opus-4.8 and claude-fable-5 while the runner pinned temperature 0.
  * These tests build the client the way the execution turn does and read the
- * request parameters offline; no request leaves the process.
+ * request parameters offline; no request leaves the process. The same holds
+ * for the thinking parameter and the output ceiling the turn now sends: the
+ * wrapper's own handling of them (sent only when set, sampling stripped
+ * under thinking) is what reaches the provider.
  */
 import { ChatAnthropic } from "@langchain/anthropic";
 import { afterEach, beforeEach, describe, expect, it, vi } from "vitest";
 
-import { buildChatModel } from "../model-client.js";
+import { buildChatModel, type BuildChatModelOptions } from "../model-client.js";
+import { BUDGET_THINKING_TOKENS } from "../thinking-mode.js";
 import { _resetRegistryCache } from "../model-registry.js";
 
 // Ids the wrapper treats as adaptive-only and refuses a sampling override
@@ -54,3 +58,53 @@ describe("the native execution turn's sampling parameters (real @langchain/anthr
     },
   );
 });
+
+describe("the native execution turn's thinking and ceiling (real @langchain/anthropic)", () => {
+  beforeEach(() => {
+    _resetRegistryCache();
+    vi.spyOn(globalThis, "fetch").mockRejectedValue(new Error("registry unreachable in this test"));
+    vi.spyOn(console, "warn").mockImplementation(() => {});
+  });
+
+  afterEach(() => {
+    _resetRegistryCache();
+    vi.restoreAllMocks();
+  });
+
+  async function params(modelName: string, extra: Partial<BuildChatModelOptions>) {
+    const { model } = await buildChatModel({
+      modelName,
+      proxyEndpoint: "http://127.0.0.1:9",
+      stigmerToken: "sampling-test",
+      temperature: null,
+      ...extra,
+    });
+    return (model as ChatAnthropic).invocationParams({});
+  }
+
+  it.each(ADAPTIVE_ONLY_IDS)("%s: adaptive thinking with summarized display reaches the request", async (id) => {
+    const request = await params(id, { thinking: { type: "adaptive", display: "summarized" } });
+    expect(request.thinking).toEqual({ type: "adaptive", display: "summarized" });
+    expect(request).not.toHaveProperty("temperature");
+  });
+
+  it("a budget row's fixed budget reaches the request below the row's ceiling", async () => {
+    const request = await params("claude-haiku-4-5-20251001", {
+      thinking: { type: "enabled", budget_tokens: BUDGET_THINKING_TOKENS },
+      maxTokens: 64000,
+      streaming: true,
+    });
+    expect(request.thinking).toEqual({ type: "enabled", budget_tokens: BUDGET_THINKING_TOKENS });
+    expect(request.max_tokens).toBe(64000);
+  });
+
+  it("an explicit disabled is sent as such, and an omitted one is not sent at all", async () => {
+    expect((await params("claude-sonnet-5", { thinking: { type: "disabled" } })).thinking).toEqual({ type: "disabled" });
+    expect((await params("claude-sonnet-5", {})).thinking).toBeUndefined();
+  });
+
+  it("the row's full ceiling builds with streaming on, where the library default would be 4096", async () => {
+    expect((await params("claude-sonnet-5", {})).max_tokens).toBe(4096);
+    expect((await params("claude-sonnet-5", { maxTokens: 128000, streaming: true })).max_tokens).toBe(128000);
+  });
+});

package/src/shared/__tests__/model-client.test.ts

@@ -388,6 +388,78 @@ describe("buildChatModel", () => {
       .rejects.toThrow(/STIGMER_ANTHROPIC_BACKEND="verteks" is not a supported backend/);
   });
 
+  describe("thinking and streaming (the native execution turn)", () => {
+    it("Anthropic: the mapped thinking parameter is the wrapper's own `thinking` field", async () => {
+      mockRegistryResponse([
+        { id: "claude-sonnet-5", apiModelId: "claude-sonnet-5", provider: "anthropic" },
+      ]);
+
+      await buildChatModel({ modelName: "claude-sonnet-5", thinking: { type: "adaptive", display: "summarized" } });
+
+      expect(lastAnthropicArgs()).toMatchObject({ thinking: { type: "adaptive", display: "summarized" } });
+    });
+
+    it("an explicit disabled rides the same field, so the provider's default cannot turn thinking on", async () => {
+      mockRegistryResponse([
+        { id: "claude-sonnet-5", apiModelId: "claude-sonnet-5", provider: "anthropic" },
+      ]);
+
+      await buildChatModel({ modelName: "claude-sonnet-5", thinking: { type: "disabled" } });
+
+      expect(lastAnthropicArgs()).toMatchObject({ thinking: { type: "disabled" } });
+    });
+
+    it("an omitted thinking parameter sends none, and streaming is off unless asked for", async () => {
+      mockRegistryResponse([
+        { id: "claude-haiku-4.5", apiModelId: "claude-haiku-4-5-20251001", provider: "anthropic" },
+      ]);
+
+      await buildChatModel({ modelName: "claude-haiku-4.5" });
+
+      expect(lastAnthropicArgs()).not.toHaveProperty("thinking");
+      expect(lastAnthropicArgs()).not.toHaveProperty("streaming");
+    });
+
+    it("streaming and the row's ceiling reach the wrapper when the caller sets them", async () => {
+      mockRegistryResponse([
+        { id: "claude-opus-4.8", apiModelId: "claude-opus-4-8", provider: "anthropic" },
+      ]);
+
+      await buildChatModel({ modelName: "claude-opus-4.8", maxTokens: 128000, streaming: true });
+
+      expect(lastAnthropicArgs()).toMatchObject({ maxTokens: 128000, streaming: true });
+    });
+
+    it("thinking rides a backend request too — unlike the tier, it exists on every Anthropic platform", async () => {
+      process.env.STIGMER_ANTHROPIC_BACKEND = "vertex";
+      process.env.CLOUD_ML_REGION = "asia-south1";
+      mockRegistryResponse([
+        { id: "claude-sonnet-4.5", apiModelId: "claude-sonnet-4-5-20250929", provider: "anthropic" },
+      ]);
+
+      await buildChatModel({
+        modelName: "claude-sonnet-4.5",
+        thinking: { type: "enabled", budget_tokens: 16000 },
+        serviceTier: ServiceTier.STANDARD,
+      });
+
+      const args = lastAnthropicArgs();
+      expect(args).toMatchObject({ thinking: { type: "enabled", budget_tokens: 16000 } });
+      expect(args).not.toHaveProperty("invocationKwargs");
+    });
+
+    it("a thinking parameter for a non-Anthropic model is refused, never silently dropped", async () => {
+      mockRegistryResponse([
+        { id: "gpt-4.1", apiModelId: "gpt-4.1", provider: "openai" },
+      ]);
+
+      await expect(
+        buildChatModel({ modelName: "gpt-4.1", thinking: { type: "adaptive" } }),
+      ).rejects.toThrow(/only Anthropic models have a native thinking mapping/);
+      expect(mockOpenAICtor).not.toHaveBeenCalled();
+    });
+  });
+
   describe("service tier (stigmer/stigmer#361)", () => {
     // The #357 contract on the native harness: when the caller passes the
     // execution's effective tier, every provider request pins it

package/src/shared/__tests__/model-registry.test.ts

@@ -4,6 +4,7 @@ import {
   getEconomyModel,
   getDefaultModel,
   getModelVisionCapability,
+  getNativeRequestProfile,
   resolveToApiModelId,
   _resetRegistryCache,
 } from "../model-registry.js";
@@ -345,6 +346,99 @@ describe("getModelVisionCapability", () => {
   });
 });
 
+describe("getNativeRequestProfile", () => {
+  beforeEach(() => {
+    _resetRegistryCache();
+    vi.restoreAllMocks();
+  });
+
+  afterEach(() => {
+    _resetRegistryCache();
+  });
+
+  const NO_THINKING = { shape: "none", required: undefined } as const;
+
+  it("reads the native row, never the same id's cursor row", async () => {
+    mockRegistryResponse([
+      { id: "claude-sonnet-5", provider: "anthropic", costTier: "standard", harness: "cursor", maxOutputTokens: 64000, capabilities: { thinking: true, adaptiveThinking: false } },
+      { id: "claude-sonnet-5", apiModelId: "claude-sonnet-5", provider: "anthropic", costTier: "standard", harness: "native", maxOutputTokens: 128000, capabilities: { thinking: false, adaptiveThinking: true, thinkingRequired: false } },
+    ]);
+
+    expect(await getNativeRequestProfile("claude-sonnet-5")).toEqual({
+      maxOutputTokens: 128000,
+      thinking: { shape: "adaptive", required: false },
+    });
+  });
+
+  it("matches the provider api id as well as the registry id", async () => {
+    mockRegistryResponse([
+      { id: "claude-sonnet-4.6", apiModelId: "claude-sonnet-4-6", provider: "anthropic", costTier: "standard", harness: "native", maxOutputTokens: 65536 },
+    ]);
+
+    expect(await getNativeRequestProfile("claude-sonnet-4-6")).toEqual({ maxOutputTokens: 65536, thinking: NO_THINKING });
+    expect(await getNativeRequestProfile("claude-sonnet-4.6")).toEqual({ maxOutputTokens: 65536, thinking: NO_THINKING });
+  });
+
+  it("derives the thinking shape from the capability flags, adaptive winning over budget", async () => {
+    mockRegistryResponse([
+      { id: "budget", provider: "anthropic", costTier: "standard", harness: "native", capabilities: { thinking: true, adaptiveThinking: false } },
+      { id: "adaptive", provider: "anthropic", costTier: "standard", harness: "native", capabilities: { thinking: false, adaptiveThinking: true } },
+      { id: "both", provider: "anthropic", costTier: "standard", harness: "native", capabilities: { thinking: true, adaptiveThinking: true } },
+      { id: "neither", provider: "anthropic", costTier: "standard", harness: "native", capabilities: { thinking: false, adaptiveThinking: false } },
+    ]);
+
+    expect((await getNativeRequestProfile("budget"))?.thinking.shape).toBe("budget");
+    expect((await getNativeRequestProfile("adaptive"))?.thinking.shape).toBe("adaptive");
+    expect((await getNativeRequestProfile("both"))?.thinking.shape).toBe("adaptive");
+    expect((await getNativeRequestProfile("neither"))?.thinking.shape).toBe("none");
+  });
+
+  it("keeps thinkingRequired tri-state: stated true, stated false, and never assessed", async () => {
+    mockRegistryResponse([
+      { id: "always", provider: "anthropic", costTier: "premium", harness: "native", capabilities: { adaptiveThinking: true, thinkingRequired: true } },
+      { id: "optional", provider: "anthropic", costTier: "standard", harness: "native", capabilities: { adaptiveThinking: true, thinkingRequired: false } },
+      { id: "unassessed", provider: "anthropic", costTier: "standard", harness: "native", capabilities: { adaptiveThinking: true } },
+      { id: "malformed", provider: "anthropic", costTier: "standard", harness: "native", capabilities: { adaptiveThinking: true, thinkingRequired: "yes" } },
+      { id: "no-block", provider: "anthropic", costTier: "standard", harness: "native" },
+    ]);
+
+    expect((await getNativeRequestProfile("always"))?.thinking.required).toBe(true);
+    expect((await getNativeRequestProfile("optional"))?.thinking.required).toBe(false);
+    expect((await getNativeRequestProfile("unassessed"))?.thinking.required).toBeUndefined();
+    expect((await getNativeRequestProfile("malformed"))?.thinking.required).toBeUndefined();
+    expect((await getNativeRequestProfile("no-block"))?.thinking).toEqual(NO_THINKING);
+  });
+
+  it("states no ceiling when the row's value is absent or not a positive integer", async () => {
+    mockRegistryResponse([
+      { id: "a", provider: "anthropic", costTier: "standard", harness: "native" },
+      { id: "b", provider: "anthropic", costTier: "standard", harness: "native", maxOutputTokens: "128000" },
+      { id: "c", provider: "anthropic", costTier: "standard", harness: "native", maxOutputTokens: 0 },
+      { id: "d", provider: "anthropic", costTier: "standard", harness: "native", maxOutputTokens: 1.5 },
+    ]);
+
+    for (const id of ["a", "b", "c", "d"]) {
+      expect((await getNativeRequestProfile(id))?.maxOutputTokens).toBeUndefined();
+    }
+  });
+
+  it("returns undefined for Auto, an unknown model, a cursor-only model, and an unreachable registry", async () => {
+    mockRegistryResponse([
+      { id: "composer-2.5", provider: "cursor", costTier: "economy", harness: "cursor", maxOutputTokens: 64000 },
+    ]);
+
+    expect(await getNativeRequestProfile("default")).toBeUndefined();
+    expect(await getNativeRequestProfile("")).toBeUndefined();
+    expect(await getNativeRequestProfile("composer-2.5")).toBeUndefined();
+    expect(await getNativeRequestProfile("no-such-model")).toBeUndefined();
+
+    _resetRegistryCache();
+    vi.spyOn(globalThis, "fetch").mockRejectedValueOnce(new Error("network down"));
+    vi.spyOn(console, "warn").mockImplementation(() => {});
+    expect(await getNativeRequestProfile("claude-sonnet-5")).toBeUndefined();
+  });
+});
+
 interface MockModel {
   id: string;
   apiModelId?: string;
@@ -352,7 +446,8 @@ interface MockModel {
   costTier: string;
   harness: string;
   featured?: boolean;
-  capabilities?: { vision?: boolean; toolUse?: boolean };
+  capabilities?: { vision?: boolean; toolUse?: boolean; thinking?: boolean; adaptiveThinking?: boolean; thinkingRequired?: unknown };
+  maxOutputTokens?: unknown;
 }
 
 function mockRegistryResponse(models: MockModel[]) {

package/src/shared/__tests__/thinking-mode.test.ts

@@ -0,0 +1,69 @@
+/**
+ * The native thinking mapping, enumerated: every effective mode against
+ * every form a native registry row can declare, including the tri-state
+ * `required` flag. The table is the contract the wire, the `think` tool and
+ * the structured-output strategy all read, so it is pinned whole.
+ */
+
+import { describe, expect, it } from "vitest";
+import { ThinkingMode } from "@stigmer/protos/ai/stigmer/agentic/agentexecution/v1/enum_pb";
+
+import {
+  BUDGET_THINKING_TOKENS,
+  graphThinks,
+  resolveEffectiveThinkingMode,
+  toAnthropicThinking,
+  type EffectiveThinkingMode,
+} from "../thinking-mode.js";
+import type { NativeThinkingProfile } from "../model-registry.js";
+
+const ADAPTIVE = { type: "adaptive", display: "summarized" } as const;
+const BUDGET = { type: "enabled", budget_tokens: BUDGET_THINKING_TOKENS } as const;
+const DISABLED = { type: "disabled" } as const;
+
+type Row = readonly [
+  label: string,
+  mode: EffectiveThinkingMode,
+  profile: NativeThinkingProfile | undefined,
+  wire: ReturnType<typeof toAnthropicThinking>,
+  thinks: boolean,
+];
+
+const TABLE: readonly Row[] = [
+  ["enabled, adaptive row", ThinkingMode.ENABLED, { shape: "adaptive", required: false }, ADAPTIVE, true],
+  ["enabled, budget row", ThinkingMode.ENABLED, { shape: "budget", required: false }, BUDGET, true],
+  ["enabled, row with no form", ThinkingMode.ENABLED, { shape: "none", required: undefined }, undefined, false],
+  ["enabled, adaptive row never assessed for required", ThinkingMode.ENABLED, { shape: "adaptive", required: undefined }, ADAPTIVE, true],
+  ["disabled, adaptive row stating required false", ThinkingMode.DISABLED, { shape: "adaptive", required: false }, DISABLED, false],
+  ["disabled, budget row stating required false", ThinkingMode.DISABLED, { shape: "budget", required: false }, DISABLED, false],
+  ["disabled, row never assessed for required", ThinkingMode.DISABLED, { shape: "adaptive", required: undefined }, undefined, false],
+  ["disabled, row that requires thinking", ThinkingMode.DISABLED, { shape: "adaptive", required: true }, ADAPTIVE, true],
+  ["enabled, row that requires thinking", ThinkingMode.ENABLED, { shape: "adaptive", required: true }, ADAPTIVE, true],
+  ["disabled, budget row that requires thinking", ThinkingMode.DISABLED, { shape: "budget", required: true }, BUDGET, true],
+  ["disabled, row with no form stating required false: no parameter to pin", ThinkingMode.DISABLED, { shape: "none", required: false }, undefined, false],
+  ["enabled, no native row", ThinkingMode.ENABLED, undefined, undefined, false],
+  ["disabled, no native row", ThinkingMode.DISABLED, undefined, undefined, false],
+];
+
+describe("toAnthropicThinking and graphThinks", () => {
+  it.each(TABLE)("%s", (_label, mode, profile, wire, thinks) => {
+    expect(toAnthropicThinking(mode, profile)).toEqual(wire);
+    expect(graphThinks(mode, profile)).toBe(thinks);
+  });
+
+  it("keeps the budget inside the provider's bounds on every budget row the registry carries", () => {
+    // The provider requires at least 1,024 and less than max_tokens; the
+    // smallest budget-row ceiling in the bundled registry is 64,000.
+    expect(BUDGET_THINKING_TOKENS).toBeGreaterThanOrEqual(1024);
+    expect(BUDGET_THINKING_TOKENS).toBeLessThan(64_000);
+  });
+});
+
+describe("resolveEffectiveThinkingMode", () => {
+  it("resolves UNSPECIFIED and DISABLED to DISABLED, and keeps ENABLED", () => {
+    expect(resolveEffectiveThinkingMode(undefined)).toBe(ThinkingMode.DISABLED);
+    expect(resolveEffectiveThinkingMode(ThinkingMode.UNSPECIFIED)).toBe(ThinkingMode.DISABLED);
+    expect(resolveEffectiveThinkingMode(ThinkingMode.DISABLED)).toBe(ThinkingMode.DISABLED);
+    expect(resolveEffectiveThinkingMode(ThinkingMode.ENABLED)).toBe(ThinkingMode.ENABLED);
+  });
+});

package/src/shared/model-client.ts

@@ -14,6 +14,7 @@
  */
 
 import { ChatAnthropic } from "@langchain/anthropic";
+import type { ThinkingConfigParam } from "@anthropic-ai/sdk/resources/messages";
 import { ChatOpenAI } from "@langchain/openai";
 import type { BaseChatModel } from "@langchain/core/language_models/chat_models";
 
@@ -65,10 +66,20 @@ export interface BuildChatModelOptions {
   readonly temperature?: number | null;
   /**
    * Pass-through only; intentionally no default. Anthropic requires a value,
-   * but callers differ (setup omits it, call-llm uses 4096), so the default
-   * stays the caller's decision to avoid silently changing behavior.
+   * but callers differ (the execution turn reads the registry row's
+   * maxOutputTokens, call-llm uses 4096), so the default stays the caller's
+   * decision to avoid silently changing behavior.
    */
   readonly maxTokens?: number;
+  /**
+   * Stream every request. The Anthropic SDK refuses a non-streaming request
+   * whose max_tokens implies more than ten minutes (about 21k tokens) unless
+   * a timeout is set, and STIGMER_LLM_REQUEST_TIMEOUT_MS is unset by default;
+   * a caller that raises maxTokens to a model's full output ceiling sets
+   * this so no call path (a middleware's own invoke, a summary) can meet
+   * that refusal. The agent loop already streams through streamEvents.
+   */
+  readonly streaming?: boolean;
   /**
    * Per-request bound. When omitted, defaults to the operator's
    * STIGMER_LLM_REQUEST_TIMEOUT_MS — resolved HERE, not per caller, so no
@@ -91,6 +102,17 @@ export interface BuildChatModelOptions {
    * platform-chosen economy models.
    */
   readonly serviceTier?: EffectiveServiceTier;
+  /**
+   * Anthropic's `thinking` request parameter, already mapped by the caller
+   * from the execution's effective mode and the model's native registry row
+   * (thinking-mode.ts `toAnthropicThinking`). Unlike the tier it is sent on
+   * every Anthropic backend: both thinking forms exist on the public API,
+   * Vertex, Bedrock and Foundry alike. A value for a non-Anthropic model is
+   * refused rather than dropped: no other provider has a native thinking
+   * mapping, and a silently ignored mode is the #357 class of defect.
+   * Omitted, the request carries no thinking parameter (utility calls).
+   */
+  readonly thinking?: ThinkingConfigParam;
 }
 
 /**
@@ -265,12 +287,21 @@ export async function buildChatModel(opts: BuildChatModelOptions): Promise<Built
   const maxRetries = timeoutMs !== undefined || opts.maxRetries !== undefined
     ? { maxRetries: opts.maxRetries ?? 0 }
     : {};
+  if (opts.thinking !== undefined && provider !== "anthropic") {
+    throw new Error(
+      `buildChatModel: a thinking parameter was passed for ${opts.modelName}, a ${provider} model; ` +
+        "only Anthropic models have a native thinking mapping",
+    );
+  }
+
   const common = {
     ...(opts.temperature === null ? {} : { temperature: opts.temperature ?? 0 }),
     apiKey,
     ...(maxTokens ? { maxTokens } : {}),
+    ...(opts.streaming ? { streaming: true } : {}),
     ...maxRetries,
   };
+  const anthropicThinkingField = opts.thinking !== undefined ? { thinking: opts.thinking } : {};
 
   // The request timeout lives in a different slot per wrapper: ChatOpenAI
   // reads `timeout` as a constructor field, but ChatAnthropic ignores it
@@ -339,12 +370,14 @@ export async function buildChatModel(opts: BuildChatModelOptions): Promise<Built
         new ChatAnthropic({
           model: wireModelId,
           ...common,
+          ...anthropicThinkingField,
           ...anthropicClientOptionsField,
           createClient: backendCreateClient,
         })
       : new ChatAnthropic({
           model: apiModelId,
           ...common,
+          ...anthropicThinkingField,
           ...anthropicServiceTierField,
           ...anthropicClientOptionsField,
         });