@stigmer/runner 0.1.0-dev.20261017020314.g644422724c27

package/src/shared/__tests__/memory-attachment.test.ts

@@ -0,0 +1,183 @@
+/**
+ * The memory capture attachment: the recall-snapshot gate
+ * (enabled bit, zero-facts included), both connection shapes with the
+ * capture-context carriers, the structural approval-freedom of
+ * synthesized attachments, and the cross-repo string pins (route +
+ * context keys, guarded here and in the mcp-server memory integration
+ * test — the TOOL_CALL_LIMIT precedent). The slug and roster are
+ * runner-internal and guarded here alone.
+ */
+
+import { create } from "@bufbuild/protobuf";
+import { describe, expect, it } from "vitest";
+import { RecalledMemoriesSchema } from "@stigmer/apis/ai/stigmer/agentic/run/v1/spec_pb";
+
+import { buildMcpApprovalDefault, type ActiveLeases } from "../approval-policy.js";
+import { listTurnTools } from "../mcp-tool-listing.js";
+import {
+  MEMORY_AGENT_ID_ENV,
+  MEMORY_AGENT_ID_HEADER,
+  MEMORY_ATTACHMENT_SLUG,
+  MEMORY_EXECUTION_ID_ENV,
+  MEMORY_EXECUTION_ID_HEADER,
+  MEMORY_ORG_ENV,
+  MEMORY_ORG_HEADER,
+  MEMORY_ROUTE,
+  MEMORY_SESSION_ID_ENV,
+  MEMORY_SESSION_ID_HEADER,
+  memoryCaptureEnabled,
+  synthesizeMemoryAttachment,
+  type MemoryCaptureContext,
+} from "../memory-attachment.js";
+import { STDIO_CREDENTIAL_ENV } from "../synthesized-attachment.js";
+
+const context: MemoryCaptureContext = {
+  org: "acme",
+  agentId: "agt_1",
+  sessionId: "ses_1",
+  agentExecutionId: "aex_1",
+};
+
+const cloudOptions = {
+  bridgeEndpoint: "https://mcp.stigmer.ai/",
+  credential: "sandbox-token",
+  backendEndpoint: "http://localhost:7234",
+};
+
+const ossOptions = {
+  bridgeEndpoint: null,
+  credential: null,
+  backendEndpoint: "http://localhost:7234",
+};
+
+const noLeases: ActiveLeases = {
+  global: false,
+  categories: new Set(),
+  servers: new Set(),
+  hooks: new Set(),
+};
+
+describe("memoryCaptureEnabled (the injection signal)", () => {
+  it("is the snapshot's enabled bit — absent and disabled read false", () => {
+    expect(memoryCaptureEnabled(undefined)).toBe(false);
+    expect(memoryCaptureEnabled(create(RecalledMemoriesSchema, { enabled: false }))).toBe(false);
+    expect(memoryCaptureEnabled(create(RecalledMemoriesSchema, { enabled: true }))).toBe(true);
+  });
+
+  it("enabled with ZERO facts still offers the tool — memory on, nothing stored yet", () => {
+    const snapshot = create(RecalledMemoriesSchema, { enabled: true, facts: [] });
+    expect(memoryCaptureEnabled(snapshot)).toBe(true);
+    expect(synthesizeMemoryAttachment(snapshot, context, cloudOptions)).toBeDefined();
+  });
+});
+
+describe("synthesizeMemoryAttachment", () => {
+  const enabled = create(RecalledMemoriesSchema, { enabled: true });
+
+  it("returns undefined when the snapshot is absent or disabled — honest absence", () => {
+    expect(synthesizeMemoryAttachment(undefined, context, cloudOptions)).toBeUndefined();
+    expect(
+      synthesizeMemoryAttachment(
+        create(RecalledMemoriesSchema, { enabled: false }),
+        context,
+        cloudOptions,
+      ),
+    ).toBeUndefined();
+  });
+
+  it("builds the HTTP shape against the bridge /memory route with credential + context headers", () => {
+    const attachment = synthesizeMemoryAttachment(enabled, context, cloudOptions);
+    expect(attachment).toMatchObject({
+      slug: MEMORY_ATTACHMENT_SLUG,
+      connectionType: "http",
+      url: "https://mcp.stigmer.ai/memory",
+      headers: {
+        Authorization: "Bearer sandbox-token",
+        [MEMORY_ORG_HEADER]: "acme",
+        [MEMORY_AGENT_ID_HEADER]: "agt_1",
+        [MEMORY_SESSION_ID_HEADER]: "ses_1",
+        [MEMORY_EXECUTION_ID_HEADER]: "aex_1",
+      },
+    });
+  });
+
+  it("builds the OSS stdio shape: the CLI-embedded bridge with the memory roster + context env", () => {
+    const attachment = synthesizeMemoryAttachment(enabled, context, ossOptions);
+    expect(attachment).toMatchObject({
+      connectionType: "stdio",
+      command: "stigmer",
+      args: ["mcp-server"],
+      env: {
+        STIGMER_MCP_ROSTER: "memory",
+        STIGMER_SERVER_ADDRESS: "localhost:7234",
+        [MEMORY_ORG_ENV]: "acme",
+        [MEMORY_AGENT_ID_ENV]: "agt_1",
+        [MEMORY_SESSION_ID_ENV]: "ses_1",
+        [MEMORY_EXECUTION_ID_ENV]: "aex_1",
+      },
+    });
+  });
+
+  it("the stdio child receives the run's credential as its startup bearer — the same credential the bridge shape presents per request", () => {
+    const attachment = synthesizeMemoryAttachment(enabled, context, {
+      ...ossOptions,
+      credential: "run-credential",
+    });
+    expect(attachment?.connectionType).toBe("stdio");
+    expect(attachment?.env).toMatchObject({
+      [STDIO_CREDENTIAL_ENV]: "run-credential",
+      STIGMER_MCP_ROSTER: "memory",
+    });
+    // The child's environment is byte-for-byte today's when the run carried no credential.
+    expect(synthesizeMemoryAttachment(enabled, context, ossOptions)?.env).not.toHaveProperty(
+      STDIO_CREDENTIAL_ENV,
+    );
+  });
+
+  it("omits empty context fields from the carrier — best-effort attribution, never blank entries", () => {
+    const partial: MemoryCaptureContext = {
+      org: "acme",
+      agentId: "",
+      sessionId: "ses_1",
+      agentExecutionId: "",
+    };
+
+    const http = synthesizeMemoryAttachment(enabled, partial, cloudOptions);
+    expect(Object.keys(http?.headers ?? {}).sort()).toEqual([
+      "Authorization",
+      MEMORY_ORG_HEADER,
+      MEMORY_SESSION_ID_HEADER,
+    ].sort());
+
+    const stdio = synthesizeMemoryAttachment(enabled, partial, ossOptions);
+    expect(stdio?.env).not.toHaveProperty(MEMORY_AGENT_ID_ENV);
+    expect(stdio?.env).not.toHaveProperty(MEMORY_EXECUTION_ID_ENV);
+  });
+
+  it("pins the cross-repo strings the mcp-server side guards too", () => {
+    expect(MEMORY_ATTACHMENT_SLUG).toBe("stigmer-memory");
+    expect(MEMORY_ROUTE).toBe("/memory");
+    expect(MEMORY_ORG_HEADER).toBe("x-stigmer-memory-org");
+    expect(MEMORY_AGENT_ID_HEADER).toBe("x-stigmer-memory-agent-id");
+    expect(MEMORY_SESSION_ID_HEADER).toBe("x-stigmer-memory-session-id");
+    expect(MEMORY_EXECUTION_ID_HEADER).toBe("x-stigmer-memory-execution-id");
+    expect(MEMORY_ORG_ENV).toBe("STIGMER_MEMORY_ORG");
+    expect(MEMORY_AGENT_ID_ENV).toBe("STIGMER_MEMORY_AGENT_ID");
+    expect(MEMORY_SESSION_ID_ENV).toBe("STIGMER_MEMORY_SESSION_ID");
+    expect(MEMORY_EXECUTION_ID_ENV).toBe("STIGMER_MEMORY_EXECUTION_ID");
+  });
+
+  it("is approval-free by construction: never listed, so the approval default asks for none of its tools", async () => {
+    // Consent is the confirm RPC, not tool approval: the
+    // tool only creates a proposal, so gating it would stack a second
+    // consent gate in front of the real one.
+    const attachment = synthesizeMemoryAttachment(enabled, context, cloudOptions)!;
+    expect(attachment.home, "the platform's own server, no plugin's").toEqual({ kind: "platform" });
+    const listing = await listTurnTools([attachment], () => Promise.reject(new Error("a platform server is never listed")));
+    expect(listing).toEqual({ listed: [], destructive: [], unlisted: [] });
+    const mcpDefault = buildMcpApprovalDefault(listing, noLeases);
+    expect(mcpDefault.destructive.size).toBe(0);
+    expect(mcpDefault.unlisted.size).toBe(0);
+  });
+
+});

package/src/shared/__tests__/memory-retrieval.test.ts

@@ -0,0 +1,310 @@
+/**
+ * Unit tests for the memory-retrieval module (stigmer/stigmer#293). What
+ * is pinned here, path by path:
+ *
+ *  - The activation threshold: selection runs ONLY above RETRIEVAL_K
+ *    candidates; at or below it there is NO embeddings call (most users
+ *    never touch the embeddings API — the activation contract).
+ *  - Top-k correctness and the presentation contract: selection is by
+ *    relevance, presentation is snapshot order, ties break toward the
+ *    lower snapshot index (deterministic across invocations).
+ *  - The failure posture: every degraded path — no embedder, embed error,
+ *    malformed response — injects wholesale with an honest
+ *    selection_active=false report, never a throw into prompt build.
+ *  - The written-once replay: a prior report (either polarity) replays
+ *    without an embeddings call, so a re-invocation can never inject a
+ *    different subset than the first invocation did.
+ *  - The report contract: a report exists exactly when facts are injected;
+ *    no injection, no report (absent report = wholesale by construction).
+ */
+
+import { describe, it, expect, vi, afterEach } from "vitest";
+import { create } from "@bufbuild/protobuf";
+import { RecalledMemoriesSchema } from "@stigmer/apis/ai/stigmer/agentic/run/v1/spec_pb";
+
+import {
+  selectRecalledFacts,
+  RETRIEVAL_K,
+  EMBEDDING_MODEL,
+  QUERY_MAX_CHARS,
+  type EmbedFn,
+} from "../memory-retrieval.js";
+import { RecalledMemoriesReportSchema } from "../../gen/turn/ai/stigmer/runner/turn/v1/rows_pb.js";
+
+const QUERY = "How should I deploy the payments service?";
+
+/** Snapshot of `count` facts: mem_0..mem_{count-1}, "fact 0".."fact N". */
+function snapshot(count: number) {
+  return create(RecalledMemoriesSchema, {
+    enabled: true,
+    facts: Array.from({ length: count }, (_, i) => ({
+      memoryId: `mem_${i}`,
+      content: `fact ${i}`,
+    })),
+  });
+}
+
+/**
+ * A deterministic embedder over 2D unit vectors: the query embeds to
+ * [1, 0]; fact i embeds to an angle that grows with i, so relevance order
+ * is exactly snapshot order (fact 0 most similar) unless a test overrides
+ * per-input vectors.
+ */
+function angularEmbedder(overrides?: Map<string, number[]>): EmbedFn & {
+  calls: string[][];
+} {
+  const calls: string[][] = [];
+  const fn: EmbedFn = async (inputs) => {
+    calls.push([...inputs]);
+    return inputs.map((input, position) => {
+      const override = overrides?.get(input);
+      if (override) return override;
+      if (position === 0) return [1, 0];
+      const angle = (position / (inputs.length + 1)) * (Math.PI / 2);
+      return [Math.cos(angle), Math.sin(angle)];
+    });
+  };
+  return Object.assign(fn, { calls });
+}
+
+function baseOptions(embed: EmbedFn) {
+  return {
+    proxyEndpoint: null,
+    stigmerToken: null,
+    executionId: "exec_test",
+    embed,
+  };
+}
+
+afterEach(() => {
+  vi.unstubAllEnvs();
+});
+
+describe("selectRecalledFacts — no injection, no report", () => {
+  it("answers nothing for an absent snapshot (executions from before the recall snapshot)", async () => {
+    const embed = angularEmbedder();
+    const result = await selectRecalledFacts(undefined, QUERY, baseOptions(embed));
+    expect(result.content).toBeUndefined();
+    expect(result.report).toBeUndefined();
+    expect(embed.calls).toHaveLength(0);
+  });
+
+  it("answers nothing when recall is disabled or enabled-with-zero-facts", async () => {
+    const embed = angularEmbedder();
+    const disabled = create(RecalledMemoriesSchema, {
+      enabled: false,
+      facts: [{ memoryId: "mem_0", content: "fact 0" }],
+    });
+    expect(
+      (await selectRecalledFacts(disabled, QUERY, baseOptions(embed))).report,
+    ).toBeUndefined();
+    const empty = create(RecalledMemoriesSchema, { enabled: true });
+    expect(
+      (await selectRecalledFacts(empty, QUERY, baseOptions(embed))).report,
+    ).toBeUndefined();
+    expect(embed.calls).toHaveLength(0);
+  });
+});
+
+describe("selectRecalledFacts — activation threshold", () => {
+  it("injects wholesale with NO embeddings call at exactly k candidates", async () => {
+    const embed = angularEmbedder();
+    const result = await selectRecalledFacts(
+      snapshot(RETRIEVAL_K),
+      QUERY,
+      baseOptions(embed),
+    );
+
+    expect(embed.calls).toHaveLength(0);
+    expect(result.content?.facts).toHaveLength(RETRIEVAL_K);
+    expect(result.report?.selectionActive).toBe(false);
+    expect(result.report?.injectedMemoryIds).toEqual([]);
+    expect(result.report?.embeddingModel).toBe("");
+  });
+
+  it("activates selection at k+1: one batched call, k facts injected", async () => {
+    const embed = angularEmbedder();
+    const result = await selectRecalledFacts(
+      snapshot(RETRIEVAL_K + 1),
+      QUERY,
+      baseOptions(embed),
+    );
+
+    expect(embed.calls).toHaveLength(1);
+    expect(embed.calls[0]).toHaveLength(RETRIEVAL_K + 2); // query + all candidates
+    expect(embed.calls[0][0]).toBe(QUERY);
+    expect(result.content?.facts).toHaveLength(RETRIEVAL_K);
+    expect(result.report?.selectionActive).toBe(true);
+    expect(result.report?.injectedMemoryIds).toHaveLength(RETRIEVAL_K);
+    expect(result.report?.embeddingModel).toBe(EMBEDDING_MODEL);
+    // The angular embedder makes the LAST fact least relevant.
+    expect(result.report?.injectedMemoryIds).not.toContain(`mem_${RETRIEVAL_K}`);
+  });
+
+  it("counts only renderable candidates toward the threshold (blank facts dropped, the read-boundary semantics)", async () => {
+    const embed = angularEmbedder();
+    const recalled = create(RecalledMemoriesSchema, {
+      enabled: true,
+      facts: [
+        ...Array.from({ length: RETRIEVAL_K }, (_, i) => ({
+          memoryId: `mem_${i}`,
+          content: `fact ${i}`,
+        })),
+        { memoryId: "mem_blank", content: "   " },
+      ],
+    });
+
+    const result = await selectRecalledFacts(recalled, QUERY, baseOptions(embed));
+
+    expect(embed.calls).toHaveLength(0); // 20 renderable ≤ k → wholesale
+    expect(result.content?.facts).toHaveLength(RETRIEVAL_K);
+    expect(result.report?.selectionActive).toBe(false);
+  });
+});
+
+describe("selectRecalledFacts — ranking and presentation", () => {
+  it("selects by relevance but presents in snapshot order, ids parallel to facts", async () => {
+    // Invert relevance: the LAST fact is the most similar, fact 0 the least.
+    const count = RETRIEVAL_K + 5;
+    const overrides = new Map<string, number[]>();
+    for (let i = 0; i < count; i++) {
+      const angle = ((count - i) / (count + 1)) * (Math.PI / 2);
+      overrides.set(`fact ${i}`, [Math.cos(angle), Math.sin(angle)]);
+    }
+    const embed = angularEmbedder(overrides);
+
+    const result = await selectRecalledFacts(
+      snapshot(count),
+      QUERY,
+      baseOptions(embed),
+    );
+
+    // The 5 least relevant under inversion are the FIRST five snapshot facts.
+    const expectedIndices = Array.from({ length: RETRIEVAL_K }, (_, i) => i + 5);
+    expect(result.content?.facts).toEqual(expectedIndices.map((i) => `fact ${i}`));
+    expect(result.report?.injectedMemoryIds).toEqual(
+      expectedIndices.map((i) => `mem_${i}`),
+    );
+  });
+
+  it("breaks ties toward the lower snapshot index — equal scores never reorder across invocations", async () => {
+    // Every input embeds identically: all scores tie.
+    const count = RETRIEVAL_K + 3;
+    const overrides = new Map<string, number[]>([[QUERY, [1, 0]]]);
+    for (let i = 0; i < count; i++) {
+      overrides.set(`fact ${i}`, [1, 0]);
+    }
+    const embed = angularEmbedder(overrides);
+
+    const first = await selectRecalledFacts(snapshot(count), QUERY, baseOptions(embed));
+    const second = await selectRecalledFacts(snapshot(count), QUERY, baseOptions(embed));
+
+    const expected = Array.from({ length: RETRIEVAL_K }, (_, i) => `mem_${i}`);
+    expect(first.report?.injectedMemoryIds).toEqual(expected);
+    expect(second.report?.injectedMemoryIds).toEqual(expected);
+  });
+
+  it("truncates the query at QUERY_MAX_CHARS — a giant paste must not 400 the whole batch", async () => {
+    const embed = angularEmbedder();
+    const giant = "x".repeat(QUERY_MAX_CHARS + 500);
+
+    await selectRecalledFacts(snapshot(RETRIEVAL_K + 1), giant, baseOptions(embed));
+
+    expect(embed.calls[0][0]).toHaveLength(QUERY_MAX_CHARS);
+  });
+});
+
+describe("selectRecalledFacts — failure posture (never worse than wholesale injection)", () => {
+  it("degrades to wholesale with an honest report when the embedder throws", async () => {
+    const embed: EmbedFn = async () => {
+      throw new Error("connect ETIMEDOUT");
+    };
+    const result = await selectRecalledFacts(
+      snapshot(RETRIEVAL_K + 1),
+      QUERY,
+      baseOptions(embed),
+    );
+
+    expect(result.content?.facts).toHaveLength(RETRIEVAL_K + 1);
+    expect(result.report?.selectionActive).toBe(false);
+    expect(result.report?.injectedMemoryIds).toEqual([]);
+  });
+
+  it("degrades to wholesale when the embedder answers the wrong vector count", async () => {
+    const embed: EmbedFn = async () => [[1, 0]];
+    const result = await selectRecalledFacts(
+      snapshot(RETRIEVAL_K + 1),
+      QUERY,
+      baseOptions(embed),
+    );
+
+    expect(result.content?.facts).toHaveLength(RETRIEVAL_K + 1);
+    expect(result.report?.selectionActive).toBe(false);
+  });
+
+  it("injects wholesale when no embedder resolves (no proxy, no OpenAI key — the Anthropic-only OSS posture)", async () => {
+    vi.stubEnv("OPENAI_API_KEY", "");
+
+    const result = await selectRecalledFacts(snapshot(RETRIEVAL_K + 1), QUERY, {
+      proxyEndpoint: null,
+      stigmerToken: null,
+      executionId: "exec_test",
+      // No embed injected: the module resolves — and finds — nothing.
+    });
+
+    expect(result.content?.facts).toHaveLength(RETRIEVAL_K + 1);
+    expect(result.report?.selectionActive).toBe(false);
+  });
+});
+
+describe("selectRecalledFacts — written-once replay across re-invocations", () => {
+  it("replays a selection-active prior report without an embeddings call", async () => {
+    const embed = angularEmbedder();
+    const prior = create(RecalledMemoriesReportSchema, {
+      selectionActive: true,
+      injectedMemoryIds: ["mem_1", "mem_3"],
+      embeddingModel: EMBEDDING_MODEL,
+    });
+
+    const result = await selectRecalledFacts(snapshot(RETRIEVAL_K + 1), QUERY, {
+      ...baseOptions(embed),
+      priorReport: prior,
+    });
+
+    expect(embed.calls).toHaveLength(0);
+    expect(result.content?.facts).toEqual(["fact 1", "fact 3"]);
+    expect(result.report).toBe(prior);
+  });
+
+  it("replays a wholesale prior report as wholesale — a recorded embed failure is never retried into a different prompt", async () => {
+    const embed = angularEmbedder();
+    const prior = create(RecalledMemoriesReportSchema, { selectionActive: false });
+
+    const result = await selectRecalledFacts(snapshot(RETRIEVAL_K + 1), QUERY, {
+      ...baseOptions(embed),
+      priorReport: prior,
+    });
+
+    expect(embed.calls).toHaveLength(0);
+    expect(result.content?.facts).toHaveLength(RETRIEVAL_K + 1);
+    expect(result.report?.selectionActive).toBe(false);
+  });
+
+  it("re-selects when a recorded id does not resolve against the snapshot (structurally impossible, defended anyway)", async () => {
+    const embed = angularEmbedder();
+    const prior = create(RecalledMemoriesReportSchema, {
+      selectionActive: true,
+      injectedMemoryIds: ["mem_1", "mem_never_existed"],
+      embeddingModel: EMBEDDING_MODEL,
+    });
+
+    const result = await selectRecalledFacts(snapshot(RETRIEVAL_K + 1), QUERY, {
+      ...baseOptions(embed),
+      priorReport: prior,
+    });
+
+    expect(embed.calls).toHaveLength(1);
+    expect(result.report?.selectionActive).toBe(true);
+    expect(result.report?.injectedMemoryIds).toHaveLength(RETRIEVAL_K);
+  });
+});

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

@@ -0,0 +1,110 @@
+/**
+ * The native execution turn's request against the REAL @langchain/anthropic
+ * (stigmer/stigmer#1341): the unit suite in model-client.test.ts mocks the
+ * wrapper, so it cannot see the wrapper's own parameter validation. That
+ * 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. 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, 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
+// for, and ids it lets one through for (the provider itself refuses it on
+// claude-sonnet-5); the registry is unreachable in these tests, so each id
+// reaches the wrapper unchanged.
+const ADAPTIVE_ONLY_IDS = ["claude-opus-4-7", "claude-opus-4-8", "claude-fable-5"];
+const SAMPLING_TOLERANT_IDS = ["claude-sonnet-4-6", "claude-opus-4-6", "claude-sonnet-5", "claude-haiku-4-5-20251001"];
+
+async function executionTurnParams(modelName: string, temperature: number | null | undefined) {
+  const { model } = await buildChatModel({
+    modelName,
+    proxyEndpoint: "http://127.0.0.1:9",
+    stigmerToken: "sampling-test",
+    temperature,
+  });
+  return (model as ChatAnthropic).invocationParams({});
+}
+
+describe("the native execution turn's sampling parameters (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();
+  });
+
+  it.each(ADAPTIVE_ONLY_IDS)("%s: the pinned temperature 0 is refused before any request", async (id) => {
+    await expect(executionTurnParams(id, undefined)).rejects.toThrow(/temperature is not supported/);
+  });
+
+  it.each([...ADAPTIVE_ONLY_IDS, ...SAMPLING_TOLERANT_IDS])(
+    "%s: with no temperature the request builds and carries no sampling override",
+    async (id) => {
+      const params = await executionTurnParams(id, null);
+      expect(params).not.toHaveProperty("temperature");
+    },
+  );
+});
+
+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);
+  });
+});