@pensar/apex 2.6.1 → 2.7.0

package/src/core/ai/models/claude-capabilities.ts

@@ -1,22 +1,43 @@
-type ClaudeCapabilities = {
+export type ClaudeThinkingEffort = "low" | "medium" | "high" | "xhigh" | "max";
+
+export type ClaudeCapabilities = {
   alwaysOnThinking: boolean;
   bindsThinking?: boolean;
+  defaultEffort: ClaudeThinkingEffort;
 };
 
 const CLAUDE_CAPABILITIES: Record<string, ClaudeCapabilities> = {
-  "claude-sonnet-5-5": { alwaysOnThinking: true, bindsThinking: true },
-  "claude-opus-5-5": { alwaysOnThinking: true, bindsThinking: true },
-  "claude-fable-5-1": { alwaysOnThinking: true, bindsThinking: true },
-  "claude-opus-5": { alwaysOnThinking: false },
-  "claude-sonnet-5": { alwaysOnThinking: false },
-  "claude-fable-5": { alwaysOnThinking: true },
+  "claude-haiku-5-5": {
+    alwaysOnThinking: false,
+    bindsThinking: true,
+    defaultEffort: "medium",
+  },
+  "claude-sonnet-5-5": {
+    alwaysOnThinking: true,
+    bindsThinking: true,
+    defaultEffort: "high",
+  },
+  "claude-opus-5-5": {
+    alwaysOnThinking: true,
+    bindsThinking: true,
+    defaultEffort: "medium",
+  },
+  "claude-fable-5-1": {
+    alwaysOnThinking: true,
+    bindsThinking: true,
+    defaultEffort: "high",
+  },
+  "claude-opus-5": { alwaysOnThinking: false, defaultEffort: "high" },
+  "claude-sonnet-5": { alwaysOnThinking: false, defaultEffort: "high" },
+  "claude-fable-5": { alwaysOnThinking: true, defaultEffort: "high" },
 };
 
 export function getClaudeCapabilities(
   modelId: string,
 ): ClaudeCapabilities | undefined {
   const nativeId = modelId
-    .replace(/^(concentrate:|anthropic\/)/, "")
+    .replace(/^(concentrate:|pensar:)/, "")
+    .replace(/^(?:(?:us|global|eu|au|jp)\.)?anthropic[./]/, "")
     .replace(/(\d)\.(\d)/g, "$1-$2");
   return CLAUDE_CAPABILITIES[nativeId];
 }

package/src/core/ai/models/index.ts

@@ -12,7 +12,10 @@ import { ANTHROPIC_MODELS } from "./anthropic";
 import { BEDROCK_MODELS } from "./bedrock";
 import { getClaudeCapabilities } from "./claude-capabilities";
 
-export { getClaudeCapabilities } from "./claude-capabilities";
+export {
+  type ClaudeThinkingEffort,
+  getClaudeCapabilities,
+} from "./claude-capabilities";
 
 import { CONCENTRATE_MODELS } from "./concentrate";
 import { GOOGLE_MODELS } from "./google";

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

@@ -103,6 +103,11 @@ describe("getMaxOutputTokens", () => {
   });
 
   it("recognizes Claude tier-specific budgets", () => {
+    expect(getMaxOutputTokens("claude-haiku-5-5")).toBe(128_000);
+    expect(getMaxOutputTokens("global.anthropic.claude-haiku-5-5")).toBe(
+      128_000,
+    );
+    expect(getMaxOutputTokens("anthropic/claude-haiku-5.5")).toBe(128_000);
     expect(getMaxOutputTokens("claude-sonnet-4-5-20250929")).toBe(64_000);
     expect(getMaxOutputTokens("claude-opus-4-5-20250101")).toBe(64_000);
     expect(getMaxOutputTokens("claude-haiku-4-5-20251001")).toBe(64_000);
@@ -111,6 +116,24 @@ describe("getMaxOutputTokens", () => {
     expect(getMaxOutputTokens("claude-3-5-haiku-20241022")).toBe(8_192);
   });
 
+  it("registers Claude Haiku 5.5 across Anthropic, Bedrock, and OpenRouter", () => {
+    expect(getModelInfo("claude-haiku-5-5")).toMatchObject({
+      name: "Claude Haiku 5.5",
+      provider: "anthropic",
+      contextLength: 1_000_000,
+    });
+    expect(getModelInfo("global.anthropic.claude-haiku-5-5")).toMatchObject({
+      name: "Claude Haiku 5.5 (Global)",
+      provider: "bedrock",
+      contextLength: 1_000_000,
+    });
+    expect(getModelInfo("anthropic/claude-haiku-5.5")).toMatchObject({
+      name: "Claude Haiku 5.5",
+      provider: "openrouter",
+      contextLength: 1_000_000,
+    });
+  });
+
   it("pins latest-tier Claude (4.6 + 4.7 + 4.8) to 128K output", () => {
     // These ship the 128K window; they MUST not fall through to the
     // generic `claude-opus-4-` / `claude-sonnet-4-` catch-alls (32K/64K)

package/src/core/ai/models/openrouter.ts

@@ -3,6 +3,12 @@
 
 import type { ModelInfo } from "../ai";
 export const OPENROUTER_MODELS: ModelInfo[] = [
+  {
+    id: "anthropic/claude-haiku-5.5",
+    name: "Claude Haiku 5.5",
+    provider: "openrouter",
+    contextLength: 1000000,
+  },
   {
     id: "anthropic/claude-sonnet-5.5",
     name: "Claude Sonnet 5.5",

package/src/core/ai/providers/anthropic-models.test.ts

@@ -12,12 +12,14 @@ import { getMaxOutputTokens } from "../models";
 import { getProviderModel } from "../utils";
 
 const boundModels = new Set([
+  "claude-haiku-5-5",
   "claude-sonnet-5-5",
   "claude-opus-5-5",
   "claude-fable-5-1",
 ]);
 
 const models = [
+  { id: "claude-haiku-5-5", required: false },
   { id: "claude-sonnet-5-5", required: true },
   { id: "claude-opus-5-5", required: true },
   { id: "claude-fable-5-1", required: true },
@@ -105,7 +107,10 @@ describe.each(models)("Anthropic $id", ({ id, required }) => {
     expect(body).toMatchObject({
       model: id,
       max_tokens: 128_000,
-      output_config: { effort: "medium", format: { type: "json_schema" } },
+      output_config: {
+        ...(enableThinking || required ? { effort: "medium" } : {}),
+        format: { type: "json_schema" },
+      },
       thinking: { type: enableThinking || required ? "adaptive" : "disabled" },
     });
     expect(body.temperature).toBeUndefined();
@@ -287,3 +292,57 @@ describe.each(models)("Anthropic $id", ({ id, required }) => {
     );
   });
 });
+
+describe("Anthropic Claude Haiku 5.5 effort", () => {
+  it.each([
+    "xhigh",
+    "max",
+  ] as const)("sends the %s effort with adaptive thinking", async (effort) => {
+    const fetchMock = vi.fn(
+      async (_input: RequestInfo | URL, _init?: RequestInit) =>
+        completion("claude-haiku-5-5"),
+    );
+    vi.stubGlobal("fetch", fetchMock);
+
+    await getProviderModel("claude-haiku-5-5", {
+      anthropicAPIKey: "test-key",
+    }).doGenerate({
+      prompt: [{ role: "user", content: [{ type: "text", text: "Check" }] }],
+      providerOptions: buildReasoningProviderOptions("claude-haiku-5-5", {
+        enableThinking: true,
+        thinkingEffort: effort,
+      }),
+    });
+
+    const call = fetchMock.mock.calls[0];
+    if (!call) throw new Error("Expected a Claude request");
+    expect(JSON.parse(String(call[1]?.body))).toMatchObject({
+      thinking: { type: "adaptive" },
+      output_config: { effort },
+    });
+  });
+
+  it("uses the documented medium effort by default", async () => {
+    const fetchMock = vi.fn(
+      async (_input: RequestInfo | URL, _init?: RequestInit) =>
+        completion("claude-haiku-5-5"),
+    );
+    vi.stubGlobal("fetch", fetchMock);
+
+    await getProviderModel("claude-haiku-5-5", {
+      anthropicAPIKey: "test-key",
+    }).doGenerate({
+      prompt: [{ role: "user", content: [{ type: "text", text: "Check" }] }],
+      providerOptions: buildReasoningProviderOptions("claude-haiku-5-5", {
+        enableThinking: true,
+      }),
+    });
+
+    const call = fetchMock.mock.calls[0];
+    if (!call) throw new Error("Expected a Claude request");
+    expect(JSON.parse(String(call[1]?.body))).toMatchObject({
+      thinking: { type: "adaptive" },
+      output_config: { effort: "medium" },
+    });
+  });
+});

package/src/core/ai/providers/bedrock-models.test.ts

@@ -0,0 +1,81 @@
+import { afterEach, describe, expect, it, vi } from "vitest";
+import { buildReasoningProviderOptions } from "../ai";
+import { getProviderModel } from "../utils";
+
+function completion() {
+  return Response.json({
+    output: {
+      message: {
+        role: "assistant",
+        content: [{ text: "ok" }],
+      },
+    },
+    stopReason: "end_turn",
+    usage: {
+      inputTokens: 12,
+      outputTokens: 2,
+      totalTokens: 14,
+    },
+  });
+}
+
+afterEach(() => vi.unstubAllGlobals());
+
+describe("Bedrock Claude Haiku 5.5", () => {
+  it("sends adaptive max effort to the global inference profile", async () => {
+    const fetchMock = vi.fn(
+      async (_input: RequestInfo | URL, _init?: RequestInit) => completion(),
+    );
+    vi.stubGlobal("fetch", fetchMock);
+
+    await getProviderModel("global.anthropic.claude-haiku-5-5", {
+      bedrock: { apiKey: "test-key", region: "us-east-1" },
+    }).doGenerate({
+      prompt: [{ role: "user", content: [{ type: "text", text: "Check" }] }],
+      providerOptions: buildReasoningProviderOptions(
+        "global.anthropic.claude-haiku-5-5",
+        { enableThinking: true, thinkingEffort: "max" },
+      ),
+    });
+
+    const call = fetchMock.mock.calls[0];
+    if (!call) throw new Error("Expected a Bedrock request");
+    expect(String(call[0])).toContain(
+      "/model/global.anthropic.claude-haiku-5-5/converse",
+    );
+    expect(new Headers(call[1]?.headers).get("authorization")).toBe(
+      "Bearer test-key",
+    );
+    expect(JSON.parse(String(call[1]?.body))).toMatchObject({
+      additionalModelRequestFields: {
+        thinking: { type: "adaptive", display: "summarized" },
+        output_config: { effort: "max" },
+      },
+    });
+  });
+
+  it("forwards thinking disabled explicitly", async () => {
+    const fetchMock = vi.fn(
+      async (_input: RequestInfo | URL, _init?: RequestInit) => completion(),
+    );
+    vi.stubGlobal("fetch", fetchMock);
+
+    await getProviderModel("global.anthropic.claude-haiku-5-5", {
+      bedrock: { apiKey: "test-key", region: "us-east-1" },
+    }).doGenerate({
+      prompt: [{ role: "user", content: [{ type: "text", text: "Check" }] }],
+      providerOptions: buildReasoningProviderOptions(
+        "global.anthropic.claude-haiku-5-5",
+        { enableThinking: false },
+      ),
+    });
+
+    const call = fetchMock.mock.calls[0];
+    if (!call) throw new Error("Expected a Bedrock request");
+    expect(JSON.parse(String(call[1]?.body))).toMatchObject({
+      additionalModelRequestFields: {
+        thinking: { type: "disabled" },
+      },
+    });
+  });
+});

package/src/core/ai/providers/gateway-models.test.ts

@@ -25,6 +25,12 @@ vi.mock("undici", async (importOriginal) => {
 });
 
 const models = [
+  {
+    slug: "claude-haiku-5-5",
+    context: 1000000,
+    openrouter: "anthropic/claude-haiku-5.5",
+    concentrate: false,
+  },
   {
     slug: "claude-sonnet-5-5",
     context: 1000000,
@@ -376,9 +382,9 @@ describe.each(routes)("Gateway $id", ({ id, upstream, provider, context }) => {
   });
 
   it("preserves the highest supported reasoning effort through the SDK", async () => {
-    const effort = upstream.includes("claude")
-      ? "high"
-      : getOpenAIReasoningEfforts(id).at(-1);
+    const claudeEffort = upstream.includes("claude-haiku-5.5") ? "max" : "high";
+    const openAIEffort = getOpenAIReasoningEfforts(id).at(-1);
+    const effort = upstream.includes("claude") ? claudeEffort : openAIEffort;
     const fetchMock = vi.fn(
       async (_input: RequestInfo | URL, _init?: RequestInit) =>
         completedResponse(upstream, openrouter),
@@ -387,9 +393,9 @@ describe.each(routes)("Gateway $id", ({ id, upstream, provider, context }) => {
     await getProviderModel(id, credentials).doGenerate({
       ...options(),
       providerOptions: buildReasoningProviderOptions(id, {
-        openAIReasoningEffort: effort,
+        openAIReasoningEffort: openAIEffort,
         enableThinking: true,
-        thinkingEffort: "high",
+        thinkingEffort: claudeEffort,
       }),
     });
     const call = fetchMock.mock.calls[0];
@@ -440,7 +446,11 @@ describe.each(routes)("Gateway $id", ({ id, upstream, provider, context }) => {
       if (!call) throw new Error("Expected structured Claude request");
       const body = JSON.parse(String(call[1]?.body));
       expect(body.reasoning.effort).toBe(
-        modelRequiresThinking(id) ? "high" : "none",
+        modelRequiresThinking(id)
+          ? /claude-opus-5[.-]5/.test(upstream)
+            ? "medium"
+            : "high"
+          : "none",
       );
       expect(
         openrouter ? body.response_format.type : body.text.format.type,

package/src/core/ai/utils.native-rollout-evidence.test.ts

@@ -46,6 +46,7 @@ vi.mock("ai", async () => {
 
 vi.mock("./ai", () => ({
   buildOpenRouterProviderOptions: vi.fn(() => undefined),
+  buildReasoningProviderOptions: vi.fn(() => undefined),
   recordContextRestart: vi.fn(async () => {}),
   streamResponse: mocks.streamResponse,
 }));