@pensar/apex 2.6.1 → 2.7.0-canary.6d9d1e0d

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 () => ({
@@ -178,6 +179,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({
@@ -440,6 +511,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,6 +155,60 @@ describe("isRepairFailClosedTool", () => {
 });
 
 describe("buildReasoningProviderOptions", () => {
+  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",
+          maxReasoningEffort: "max",
+        },
+      },
+    });
+  });
+
+  it("uses Claude Haiku 5.5 medium effort by default and can disable thinking", () => {
+    expect(
+      buildReasoningProviderOptions("global.anthropic.claude-haiku-5-5", {
+        enableThinking: true,
+      }),
+    ).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("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(