@pensar/apex 2.6.1 → 2.7.0-canary.1572d9a4

package/src/core/ai/ai.recorded-context.test.ts

@@ -7,6 +7,7 @@ import { afterEach, beforeEach, describe, expect, it, vi } from "vitest";
 import { z } from "zod";
 import { RunPersistenceError } from "../runtime/persistenceError";
 import type { RunContextRecorder } from "../runtime/runContext";
+import { estimateMessageTokens } from "./contextManagement";
 
 const state: { model?: MockLanguageModelV3 } = {};
 vi.mock("./utils", async () => ({
@@ -94,6 +95,12 @@ function streamOf(chunks: unknown[]): LanguageModelV3StreamResult {
   } as LanguageModelV3StreamResult;
 }
 
+// Compaction streams now, so the summarizer answers on doStream alongside the
+// resumed agent turn; its request carries the compaction instruction.
+function isSummaryCall(options: { prompt: unknown }): boolean {
+  return JSON.stringify(options.prompt).includes("Compact this conversation");
+}
+
 async function drain(stream: { fullStream: AsyncIterable<unknown> }) {
   for await (const _part of stream.fullStream) {
     /* consume the SDK lifecycle */
@@ -178,6 +185,76 @@ describe("pre-dispatch gate (real SDK)", () => {
 });
 
 describe("step commits (real SDK)", () => {
+  it("commits fitted in-stream context before dispatch without restoring old tool results", async () => {
+    const output = "e".repeat(8_000);
+    const seenAtDispatch: number[] = [];
+    const preparedOffsets: number[] = [];
+    const { recorder } = fakeRecorder();
+    let calls = 0;
+    state.model = new MockLanguageModelV3({
+      modelId: "small",
+      doStream: async () => {
+        const latest = recorder.latest();
+        if (latest) seenAtDispatch.push(estimateMessageTokens(latest));
+        const call = calls++;
+        return call < 8
+          ? streamOf([
+              {
+                type: "tool-call",
+                toolCallId: `c${call}`,
+                toolName: "probe",
+                input: '{"q":"x"}',
+              },
+              finishChunk(),
+            ])
+          : streamOf([...textStepChunks("done", "done"), finishChunk()]);
+      },
+    });
+
+    await drain(
+      streamResponse({
+        model: "custom:fixture:small",
+        prompt: "run probes",
+        silent: true,
+        tools: {
+          probe: {
+            description: "probe",
+            inputSchema: z.object({ q: z.string() }),
+            execute: async () => output,
+          },
+        },
+        stopWhen: stepCountIs(20),
+        contextRecorder: recorder,
+        onContextPrepared: ({ responseMessageOffset }) => {
+          preparedOffsets.push(responseMessageOffset);
+        },
+        authConfig: {
+          customProviders: {
+            fixture: {
+              baseUrl: "https://example.invalid/v1",
+              models: [
+                { id: "small", contextLength: 20_000, maxOutputTokens: 2_000 },
+              ],
+            },
+          },
+        },
+      }),
+    );
+
+    expect(calls).toBe(9);
+    expect(seenAtDispatch).toHaveLength(9);
+    expect(preparedOffsets).toEqual([0, 2, 4, 6, 8, 10, 12, 14, 16]);
+    expect(Math.max(...seenAtDispatch)).toBeLessThan(7_000);
+    const final = recorder.latest();
+    expect(final).toHaveLength(18);
+    const toolOutputLengths = final
+      ?.filter((message) => message.role === "tool")
+      .map((message) => JSON.stringify(message).length);
+    expect(
+      toolOutputLengths?.filter((length) => length < 1_000).length,
+    ).toBeGreaterThanOrEqual(4);
+  });
+
   it("commits base + cumulative response.messages per step, preserving accepted outputs in later turns", async () => {
     let call = 0;
     state.model = new MockLanguageModelV3({
@@ -353,14 +430,15 @@ describe("critical failure modes (real SDK)", () => {
     const { recorder, checkpoints } = fakeRecorder();
     state.model = new MockLanguageModelV3({
       modelId: MODEL,
-      // summarizeConversation runs generateText (doGenerate) for the summary.
-      doGenerate: async () => ({
-        content: [{ type: "text", text: "A compact summary" }],
-        finishReason: { unified: "stop", raw: "stop" },
-        usage,
-        warnings: [],
-      }),
-      doStream: async () => {
+      doStream: async (options) => {
+        if (isSummaryCall(options)) {
+          return streamOf([
+            { type: "text-start", id: "s" },
+            { type: "text-delta", id: "s", delta: "A compact summary" },
+            { type: "text-end", id: "s" },
+            finishChunk(),
+          ]);
+        }
         call++;
         if (call === 1) {
           const err = new Error(
@@ -440,6 +518,9 @@ describe("critical failure modes (real SDK)", () => {
     // Every commit is the base optionally extended, never base + base.
     const base = checkpoints[0]?.messages ?? [];
     expect(base.length).toBeGreaterThan(0);
+    expect(checkpoints.at(-1)?.messages.map((message) => message.role)).toEqual(
+      ["user", "assistant", "tool"],
+    );
     for (const c of checkpoints) {
       expect(c.messages.slice(0, base.length)).toEqual(base);
       expect(c.messages.slice(base.length, base.length * 2)).not.toEqual(base);

package/src/core/ai/ai.test.ts

@@ -155,58 +155,92 @@ describe("isRepairFailClosedTool", () => {
 });
 
 describe("buildReasoningProviderOptions", () => {
-  it("sets the bedrock reasoningConfig (and anthropic.thinking) for a Bedrock Claude model when thinking is enabled", () => {
-    // Console sandbox agents run on Bedrock; this is the path the bug starved.
-    const result = buildReasoningProviderOptions(
-      "global.anthropic.claude-opus-4-6-v1",
-      { enableThinking: true },
-    );
-    expect(result).toEqual({
-      anthropic: { thinking: { type: "adaptive" } },
+  it("sends Claude Haiku 5.5 max effort through Bedrock", () => {
+    expect(
+      buildReasoningProviderOptions("global.anthropic.claude-haiku-5-5", {
+        enableThinking: true,
+        thinkingEffort: "max",
+      }),
+    ).toEqual({
+      anthropic: {
+        thinking: { type: "adaptive", display: "summarized" },
+        effort: "max",
+      },
       bedrock: {
-        reasoningConfig: { type: "adaptive", display: "summarized" },
+        reasoningConfig: {
+          type: "adaptive",
+          display: "summarized",
+          maxReasoningEffort: "max",
+        },
       },
     });
   });
 
-  it("requests no thinking for the Bedrock recon model (Haiku 4.5), which rejects adaptive", () => {
-    // Regression: Haiku 4.5 supports extended thinking but not the adaptive
-    // type; requesting it failed recon. Non-4.6 models get no thinking.
+  it("uses Claude Haiku 5.5 medium effort by default and can disable thinking", () => {
     expect(
-      buildReasoningProviderOptions(
-        "global.anthropic.claude-haiku-4-5-20251001-v1:0",
-        { enableThinking: true },
-      ),
-    ).toBeUndefined();
-  });
-
-  it("requests no thinking for pre-4.6 thinking models (Sonnet 4.5)", () => {
-    expect(
-      buildReasoningProviderOptions("claude-sonnet-4-5", {
+      buildReasoningProviderOptions("global.anthropic.claude-haiku-5-5", {
         enableThinking: true,
       }),
-    ).toBeUndefined();
+    ).toEqual({
+      anthropic: {
+        thinking: { type: "adaptive", display: "summarized" },
+        effort: "medium",
+      },
+      bedrock: {
+        reasoningConfig: {
+          type: "adaptive",
+          display: "summarized",
+          maxReasoningEffort: "medium",
+        },
+      },
+    });
+    expect(
+      buildReasoningProviderOptions("global.anthropic.claude-haiku-5-5", {
+        enableThinking: false,
+      }),
+    ).toEqual({
+      anthropic: { thinking: { type: "disabled" } },
+      bedrock: {
+        reasoningConfig: { type: "disabled" },
+        additionalModelRequestFields: {
+          thinking: { type: "disabled" },
+        },
+      },
+    });
   });
 
-  it("requests no thinking for pre-4.6 Opus models (Opus 4.0, 4.1, 4.5)", () => {
+  it("uses the documented budget mode for legacy Claude thinking", () => {
     for (const id of [
-      "claude-opus-4-0",
+      "claude-sonnet-4-5",
       "claude-opus-4-20250514",
       "claude-opus-4-1-20250805",
       "claude-opus-4-5",
-      "global.anthropic.claude-opus-4-5-20251101-v1:0",
+      "global.anthropic.claude-haiku-4-5-20251001-v1:0",
     ]) {
       expect(
         buildReasoningProviderOptions(id, { enableThinking: true }),
-      ).toBeUndefined();
+      ).toMatchObject({
+        anthropic: { thinking: { type: "enabled", budgetTokens: 10000 } },
+      });
     }
   });
 
-  it("returns undefined when thinking is disabled and no OpenAI effort applies", () => {
+  it("sends disabled thinking without an effort when the legacy toggle is off", () => {
     expect(
       buildReasoningProviderOptions("global.anthropic.claude-opus-4-6-v1", {
         enableThinking: false,
+        thinkingEffort: "high",
       }),
+    ).toMatchObject({
+      anthropic: { thinking: { type: "disabled" } },
+      bedrock: {
+        additionalModelRequestFields: { thinking: { type: "disabled" } },
+      },
+    });
+    expect(
+      buildReasoningProviderOptions("global.anthropic.claude-opus-4-6-v1", {
+        enableThinking: false,
+      })?.anthropic?.effort,
     ).toBeUndefined();
   });
 
@@ -252,13 +286,13 @@ describe("buildReasoningProviderOptions", () => {
     ).toEqual({ openai: { reasoningEffort: "high" } });
   });
 
-  it("carries the adaptive-thinking effort hint on both anthropic and bedrock for a 4.6 model", () => {
+  it("carries adaptive effort through the native and Bedrock namespaces", () => {
     const result = buildReasoningProviderOptions(
       "global.anthropic.claude-opus-4-6-v1",
       { enableThinking: true, thinkingEffort: "low" },
     );
     expect(result?.anthropic).toEqual({
-      thinking: { type: "adaptive" },
+      thinking: { type: "adaptive", display: "summarized" },
       effort: "low",
     });
     expect(result?.bedrock).toEqual({
@@ -270,39 +304,27 @@ describe("buildReasoningProviderOptions", () => {
     });
   });
 
-  it("omits the effort hint when none is provided (model default)", () => {
-    const result = buildReasoningProviderOptions(
-      "global.anthropic.claude-opus-4-6-v1",
-      { enableThinking: true },
-    );
-    expect(result?.anthropic).toEqual({ thinking: { type: "adaptive" } });
+  it("selects the documented default when legacy thinking is enabled without effort", () => {
     expect(
-      (result?.anthropic as { effort?: string } | undefined)?.effort,
-    ).toBeUndefined();
-    expect(result?.bedrock?.reasoningConfig).toEqual({
-      type: "adaptive",
-      display: "summarized",
+      buildReasoningProviderOptions("global.anthropic.claude-opus-4-6-v1", {
+        enableThinking: true,
+      }),
+    ).toMatchObject({
+      anthropic: { effort: "high" },
+      bedrock: { reasoningConfig: { maxReasoningEffort: "high" } },
     });
   });
 
-  it("drops the effort hint when thinking is not actually used (non-adaptive model)", () => {
-    // Haiku 4.5 supports thinking but not adaptive; the effort hint must not
-    // ride along on a request that requests no thinking at all.
-    expect(
-      buildReasoningProviderOptions(
-        "global.anthropic.claude-haiku-4-5-20251001-v1:0",
-        { enableThinking: true, thinkingEffort: "high" },
-      ),
-    ).toBeUndefined();
-  });
-
-  it("ignores the effort hint when thinking is disabled", () => {
-    expect(
-      buildReasoningProviderOptions("global.anthropic.claude-opus-4-6-v1", {
-        enableThinking: false,
-        thinkingEffort: "high",
-      }),
-    ).toBeUndefined();
+  it("does not send an effort hint on a toggle-only model", () => {
+    const result = buildReasoningProviderOptions(
+      "global.anthropic.claude-haiku-4-5-20251001-v1:0",
+      { enableThinking: true, thinkingEffort: "high" },
+    );
+    expect(result?.anthropic?.thinking).toEqual({
+      type: "enabled",
+      budgetTokens: 10000,
+    });
+    expect(result?.anthropic?.effort).toBeUndefined();
   });
 });