@illuma-ai/agents 1.5.1 → 2.1.1

package/src/llm/bedrock/index.ts

@@ -38,7 +38,6 @@ import type { BaseMessage } from '@langchain/core/messages';
 import { ChatGenerationChunk, ChatResult } from '@langchain/core/outputs';
 import type { CallbackManagerForLLMRun } from '@langchain/core/callbacks/manager';
 import type { ChatBedrockConverseInput } from '@langchain/aws';
-import { isBedrockCacheSupported } from './cacheSupport';
 import {
   convertToConverseMessages,
   handleConverseStreamContentBlockStart,
@@ -53,72 +52,19 @@ import {
  */
 export type ServiceTierType = 'priority' | 'default' | 'flex' | 'reserved';
 
-/**
- * Tool cachePoint allocation strategy.
- *
- *   - 'single':  one cachePoint at the END of the tools array (whole array
- *                cached as one unit). Lightest budget use (1 cachePoint).
- *   - 'split':   split tools into groups via `toolGroupSelector`. Each
- *                non-empty group gets its own cachePoint. Use when groups
- *                have different volatility (e.g. stable core tools vs
- *                volatile MCP tools). Costs more cachePoint budget.
- *   - 'none':    no cachePoint on tools array. Use when tool definitions
- *                change every request anyway.
- */
-export type ToolCacheStrategy = 'single' | 'split' | 'none';
-
-/**
- * Group selector for `toolCacheStrategy: 'split'`. Receives the tool name
- * and returns a stable group key — tools with the same key are grouped
- * together. Group order in the output array follows first-encounter order.
- */
-export type ToolGroupSelector = (toolName: string) => string;
-
-/**
- * Default group selector — puts all tools in a single group named 'core'.
- * Equivalent to 'single' strategy but explicit. Consumers override this
- * to enable per-source grouping (e.g. by inspecting tool-name substrings
- * to separate stable framework tools from volatile MCP-sourced tools).
- */
-export const DEFAULT_TOOL_GROUP_SELECTOR: ToolGroupSelector = () => 'core';
-
 /**
  * Extended input interface with additional features:
  * - promptCache: Enable Bedrock prompt caching for tool definitions
  * - applicationInferenceProfile: Use an inference profile ARN instead of model ID
  * - serviceTier: Specify service tier (Priority, Standard, Flex, Reserved)
- * - toolCacheStrategy: How to allocate cachePoints across tools array
- * - toolGroupSelector: Group key resolver for the 'split' strategy
  */
 export interface IllumaBedrockConverseInput extends ChatBedrockConverseInput {
   /**
    * Enable Bedrock prompt caching for tool definitions.
-   * When true, adds cachePoint marker(s) to tools array per
-   * `toolCacheStrategy`. Defaults to 'single'.
+   * When true, adds cachePoint markers to tools array.
    */
   promptCache?: boolean;
 
-  /**
-   * Tool cachePoint allocation. Defaults to 'single' — one cachePoint at
-   * the end of the tools array. Set to 'split' (with `toolGroupSelector`)
-   * when different tool groups have different volatility.
-   */
-  toolCacheStrategy?: ToolCacheStrategy;
-
-  /**
-   * Group selector for 'split' strategy. Receives a tool name, returns
-   * a stable group key. Defaults to a one-group selector (equivalent
-   * to 'single').
-   */
-  toolGroupSelector?: ToolGroupSelector;
-
-  /**
-   * Additional model ID patterns to consider Bedrock-cache-supported.
-   * Defaults are in `src/llm/bedrock/cacheSupport.ts`. Use this when
-   * AWS adds a new model family before the next library release.
-   */
-  bedrockCacheModelPatterns?: readonly RegExp[];
-
   /**
    * Application Inference Profile ARN to use for the model.
    * For example, "arn:aws:bedrock:eu-west-1:123456789102:application-inference-profile/fm16bt65tzgx"
@@ -162,24 +108,11 @@ export class IllumaBedrockConverse extends ChatBedrockConverse {
   /** Service tier for model invocation */
   serviceTier?: ServiceTierType;
 
-  /** Tool cachePoint allocation strategy. */
-  toolCacheStrategy: ToolCacheStrategy;
-
-  /** Group selector for 'split' strategy. */
-  toolGroupSelector: ToolGroupSelector;
-
-  /** Optional consumer extensions to the cache-supported model allowlist. */
-  bedrockCacheModelPatterns?: readonly RegExp[];
-
   constructor(fields?: IllumaBedrockConverseInput) {
     super(fields);
     this.promptCache = fields?.promptCache ?? false;
     this.applicationInferenceProfile = fields?.applicationInferenceProfile;
     this.serviceTier = fields?.serviceTier;
-    this.toolCacheStrategy = fields?.toolCacheStrategy ?? 'single';
-    this.toolGroupSelector =
-      fields?.toolGroupSelector ?? DEFAULT_TOOL_GROUP_SELECTOR;
-    this.bedrockCacheModelPatterns = fields?.bedrockCacheModelPatterns;
 
     // Fix: Force supportsToolChoiceValues for Claude models
     // The parent constructor checks `model.includes('claude-3')` but this fails when:
@@ -250,64 +183,56 @@ export class IllumaBedrockConverse extends ChatBedrockConverse {
       }
     }
 
-    /* Allowlist-based gate (see cacheSupport.ts). Replaces the old
-     * substring heuristic — same default behavior for Claude/Anthropic/
-     * Nova models, plus extension via `bedrockCacheModelPatterns`. */
-    const cacheSupported = isBedrockCacheSupported(
-      this.model,
-      this.bedrockCacheModelPatterns,
-    );
+    // Only Claude models support cachePoint - check model name
+    const modelId = this.model.toLowerCase();
+    const isClaudeModel =
+      modelId.includes('claude') || modelId.includes('anthropic');
 
     if (
       this.promptCache &&
-      cacheSupported &&
-      this.toolCacheStrategy !== 'none' &&
+      isClaudeModel &&
       params.toolConfig?.tools &&
       Array.isArray(params.toolConfig.tools) &&
       params.toolConfig.tools.length > 0
     ) {
-      const tools = params.toolConfig.tools;
-
-      if (this.toolCacheStrategy === 'single') {
-        /* SINGLE: one cachePoint at the end of the tools array. Lightest
-         * budget use; appropriate when the entire tools array is treated
-         * as one unit and changes together. */
-        const toolsWithCache = [
-          ...tools,
-          { cachePoint: { type: 'default' } } as (typeof tools)[number],
-        ];
-        params.toolConfig.tools = toolsWithCache;
-      } else if (this.toolCacheStrategy === 'split') {
-        /* SPLIT: group tools by `toolGroupSelector` and emit a cachePoint
-         * after each non-empty group. Group order follows first-encounter
-         * order in the input. Use when groups have different volatility
-         * (e.g. stable core tools + volatile MCP tools). */
-        const groupOrder: string[] = [];
-        const groupMap = new Map<string, typeof tools>();
-        for (const tool of tools) {
-          const toolName =
-            (tool as { toolSpec?: { name?: string } }).toolSpec?.name ?? '';
-          const groupKey = this.toolGroupSelector(toolName);
-          let group = groupMap.get(groupKey);
-          if (!group) {
-            group = [];
-            groupMap.set(groupKey, group);
-            groupOrder.push(groupKey);
-          }
-          group.push(tool);
+      // Separate core tools from MCP tools
+      // MCP tools have '_mcp_' in their name (e.g., 'search_emails_mcp_Google-Workspace')
+      const coreTools: typeof params.toolConfig.tools = [];
+      const mcpTools: typeof params.toolConfig.tools = [];
+
+      for (const tool of params.toolConfig.tools) {
+        // Check if tool has a name property with '_mcp_' pattern
+        const toolName =
+          (tool as { toolSpec?: { name?: string } }).toolSpec?.name ?? '';
+        if (toolName.includes('_mcp_')) {
+          mcpTools.push(tool);
+        } else {
+          coreTools.push(tool);
         }
+      }
 
-        const toolsWithCache: typeof tools = [];
-        for (const groupKey of groupOrder) {
-          const group = groupMap.get(groupKey);
-          if (!group || group.length === 0) continue;
-          toolsWithCache.push(...group);
-          toolsWithCache.push(
-            { cachePoint: { type: 'default' } } as (typeof tools)[number],
-          );
-        }
-        params.toolConfig.tools = toolsWithCache;
+      // Build tools array with strategic cachePoints:
+      // [CoreTool1, CoreTool2, cachePoint] + [MCPTool1, MCPTool2, cachePoint]
+      const toolsWithCache: typeof params.toolConfig.tools = [];
+
+      // Add core tools with cachePoint (if any)
+      if (coreTools.length > 0) {
+        toolsWithCache.push(...coreTools);
+        toolsWithCache.push({ cachePoint: { type: 'default' } });
+      }
+
+      // Add MCP tools with their own cachePoint (if any)
+      if (mcpTools.length > 0) {
+        toolsWithCache.push(...mcpTools);
+        toolsWithCache.push({ cachePoint: { type: 'default' } });
+      }
+
+      // If no tools at all (shouldn't happen but safety check)
+      if (toolsWithCache.length === 0) {
+        toolsWithCache.push({ cachePoint: { type: 'default' } });
       }
+
+      params.toolConfig.tools = toolsWithCache;
     }
 
     // Add serviceTier support

package/src/llm/openai/index.ts

@@ -896,8 +896,8 @@ export interface XAIUsageMetadata
 }
 
 export class ChatMoonshot extends ChatOpenAI {
-  static lc_name(): 'IllumaMoonshot' {
-    return 'IllumaMoonshot';
+  static lc_name(): 'LibreChatMoonshot' {
+    return 'LibreChatMoonshot';
   }
 
   protected _convertMessages(messages: BaseMessage[]): OpenAICompletionParam[] {

package/src/llm/openai/utils/index.ts

@@ -302,10 +302,6 @@ export function _convertMessagesToOpenAIParams(
   model?: string,
   options?: ConvertMessagesOptions
 ): OpenAICompletionParam[] {
-  /* DeepSeek reasoning roundtrip (PR #136): reasoning_content on
-   * an AI message must be re-sent only when the message participates in a
-   * tool-call exchange. Track context across the message flat-map. */
-  let hasReasoningToolCallContext = false;
   // TODO: Function messages do not support array content, fix cast
   return messages.flatMap((message) => {
     let role = messageToOpenAIRole(message);
@@ -336,8 +332,6 @@ export function _convertMessagesToOpenAIParams(
       role,
       content,
     };
-    let messageHasToolCalls = false;
-    let messageIsToolResult = false;
     if (message.name != null) {
       completionParam.name = message.name;
     }
@@ -346,11 +340,17 @@ export function _convertMessagesToOpenAIParams(
       completionParam.content = '';
     }
     if (isAIMessage(message) && !!message.tool_calls?.length) {
-      messageHasToolCalls = true;
       completionParam.tool_calls = message.tool_calls.map(
         convertLangChainToolCallToOpenAI
       );
       completionParam.content = hasAnthropicThinkingBlock ? content : '';
+      if (
+        options?.includeReasoningContent === true &&
+        message.additional_kwargs.reasoning_content != null
+      ) {
+        completionParam.reasoning_content =
+          message.additional_kwargs.reasoning_content;
+      }
       if (
         options?.includeReasoningDetails === true &&
         message.additional_kwargs.reasoning_details != null
@@ -398,10 +398,14 @@ export function _convertMessagesToOpenAIParams(
       }
     } else {
       if (message.additional_kwargs.tool_calls != null) {
-        messageHasToolCalls =
-          !Array.isArray(message.additional_kwargs.tool_calls) ||
-          message.additional_kwargs.tool_calls.length > 0;
         completionParam.tool_calls = message.additional_kwargs.tool_calls;
+        if (
+          options?.includeReasoningContent === true &&
+          message.additional_kwargs.reasoning_content != null
+        ) {
+          completionParam.reasoning_content =
+            message.additional_kwargs.reasoning_content;
+        }
         if (
           options?.includeReasoningDetails === true &&
           message.additional_kwargs.reasoning_details != null
@@ -449,31 +453,10 @@ export function _convertMessagesToOpenAIParams(
         }
       }
       if ((message as ToolMessage).tool_call_id != null) {
-        messageIsToolResult = true;
         completionParam.tool_call_id = (message as ToolMessage).tool_call_id;
       }
     }
 
-    /* DeepSeek reasoning roundtrip (PR #136): emit
-     * reasoning_content only when the message is part of a tool-call
-     * exchange — either the message itself has tool_calls, or a previous
-     * AI/tool message established the context. Skipping the gate causes
-     * DeepSeek to drop reasoning content during multi-turn replays. */
-    if (
-      options?.includeReasoningContent === true &&
-      isAIMessage(message) &&
-      (hasReasoningToolCallContext || messageHasToolCalls) &&
-      typeof message.additional_kwargs.reasoning_content === 'string' &&
-      message.additional_kwargs.reasoning_content !== ''
-    ) {
-      completionParam.reasoning_content =
-        message.additional_kwargs.reasoning_content;
-    }
-
-    if (messageHasToolCalls || messageIsToolResult) {
-      hasReasoningToolCallContext = true;
-    }
-
     if (
       message.additional_kwargs.audio &&
       typeof message.additional_kwargs.audio === 'object' &&

package/src/memory/citations.ts

@@ -1,7 +1,7 @@
 /**
  * Citation decoration — Phase 2.
  *
- * Ported from a reference implementation `extensions/memory-core/src/tools.citations.ts`.
+ * Ported from upstream `extensions/memory-core/src/tools.citations.ts`.
  * Decorates memory_search hits with `[path#L{start}-L{end}]` markers so
  * the model can attribute claims back to specific memory files when it
  * uses them in its answer.
@@ -10,7 +10,7 @@
  * compute line ranges from the returned content block on the fly:
  *   - `startLine` = 1 (line 1 of the file)
  *   - `endLine`   = total number of lines in the block
- * This matches the standard output format exactly while keeping the pg
+ * This matches upstream's output format exactly while keeping the pg
  * schema chunk-free.
  */
 
@@ -48,7 +48,7 @@ function formatCitation(
 }
 
 /**
- * Decorate each hit with a citation marker. Mirrors the standard behavior:
+ * Decorate each hit with a citation marker. Mirrors upstream's behavior:
  * appends `\n\nSource: <citation>` to the content and sets `citation`.
  * When `include=false`, clears any existing citation field.
  */
@@ -69,7 +69,7 @@ export function decorateCitations<T extends CitationCandidate>(
 /**
  * Whether citations should be emitted for this call.
  *
- * The reference implementation keys `auto` off the session type (direct/group/channel). In
+ * Upstream keys `auto` off the session type (direct/group/channel). In
  * Phase 1 we only have direct chat, so `auto` => `on`. Callers that
  * later distinguish session types can pass `mode` explicitly.
  */

package/src/memory/constants.ts

@@ -26,14 +26,14 @@ export const MEMORY_PHASE_NORMAL = 'normal';
 export const MEMORY_PHASE_FLUSHING = 'memory_flushing';
 
 /**
- * Search defaults — aligned with the standard defaults.
+ * Search defaults — aligned with upstream's upstream defaults.
  *
  * Sources:
- * - `reference` → maxResults=6
- * - `reference` → maxInjectedChars=4000
+ * - `upstream reference` → maxResults=6
+ * - `upstream reference` → maxInjectedChars=4000
  *
- * Keeping these in lockstep with means the mandatory-recall tool
- * description, budget clamps, and eval corpora line up with the standard
+ * Keeping these in lockstep with upstream means the mandatory-recall tool
+ * description, budget clamps, and eval corpora line up with upstream's
  * tuning — we inherit their calibration instead of re-tuning from scratch.
  */
 export const DEFAULT_MAX_SEARCH_RESULTS = 6;
@@ -45,11 +45,11 @@ export const HYBRID_VECTOR_WEIGHT = 0.7;
 export const HYBRID_TEXT_WEIGHT = 0.3;
 
 /**
- * Phase 2 rerank defaults — ported from a reference implementation.
+ * Phase 2 rerank defaults — ported from upstream.
  *
  * Sources:
- * - `reference` → lambda=0.7
- * - `reference` → halfLifeDays=30
+ * - `upstream reference` → lambda=0.7
+ * - `upstream reference` → halfLifeDays=30
  *
  * Both features are opt-in (enabled=false by default) — the Phase 2
  * features are layered on top of hybrid search and don't change default
@@ -63,11 +63,11 @@ export const DEFAULT_RECALL_TRACKING_ENABLED = false;
 export const DEFAULT_CITATIONS_MODE = 'auto' as const;
 
 /**
- * Flush trigger margins (token counts) — aligned with standard.
+ * Flush trigger margins (token counts) — aligned with upstream upstream.
  *
  * Sources:
- * - `reference` → softThreshold=4000
- * - `reference` → reserveFloor=20000
+ * - `upstream reference` → softThreshold=4000
+ * - `upstream reference` → reserveFloor=20000
  */
 export const DEFAULT_FLUSH_SOFT_THRESHOLD_TOKENS = 4000;
 export const DEFAULT_FLUSH_RESERVE_FLOOR_TOKENS = 20000;
@@ -79,7 +79,7 @@ export const DEFAULT_MAX_APPENDS_PER_FLUSH = 20;
  * Hard cap on agentic loop iterations inside {@link runMemoryFlush}.
  *
  * Each iteration = one model.invoke() followed by execution of any
- * `memory_append` tool_calls it emits. Mirrors the standard flush-plan
+ * `memory_append` tool_calls it emits. Mirrors upstream's flush-plan
  * loop cap; 8 is enough for ~2–3 reflections of batched notes while
  * protecting against runaway cycles if the model refuses to stop.
  */
@@ -97,9 +97,9 @@ export const MEMORY_APPEND_TOOL_NAME = 'memory_append';
  * Mandatory-recall description — the single most load-bearing line in the
  * whole memory system. Do not soften, shorten, or reword without an eval run.
  *
- * Ported VERBATIM from a reference implementation `extensions/memory-core/src/tools.ts:186`.
+ * Ported VERBATIM from upstream `extensions/memory-core/src/tools.ts:186`.
  * The wiki/corpus clause is retained even though Phase 1 doesn't ship
- * compiled-wiki supplements — keeping the string identical means the standard
+ * compiled-wiki supplements — keeping the string identical means upstream's
  * eval corpora remain drop-in valid.
  */
 export const MEMORY_SEARCH_DESCRIPTION =
@@ -111,7 +111,7 @@ export const MEMORY_SEARCH_DESCRIPTION =
   'unavailable and should be surfaced to the user.';
 
 /**
- * Ported VERBATIM from a reference implementation `extensions/memory-core/src/tools.ts:322`.
+ * Ported VERBATIM from upstream `extensions/memory-core/src/tools.ts:322`.
  */
 export const MEMORY_GET_DESCRIPTION =
   'Safe snippet read from MEMORY.md or memory/*.md with optional from/lines; ' +
@@ -122,7 +122,7 @@ export const MEMORY_GET_DESCRIPTION =
  * `memory_append` tool description.
  *
  * Phase 1 historically wrote to a single date-keyed file
- * (`memory/YYYY-MM-DD.md`), ported verbatim from a reference implementation. That scheme
+ * (`memory/YYYY-MM-DD.md`), ported verbatim from upstream. That scheme
  * is now replaced by an 8-path canonical whitelist — see
  * {@link ./paths.MEMORY_ALL_PATHS}. The tool description no longer
  * names a specific file; the flush-turn prompt renders the full rubric
@@ -137,7 +137,7 @@ export const MEMORY_APPEND_DESCRIPTION =
 
 /**
  * Reply token that signals the flush turn produced no user-visible output.
- * Ported VERBATIM from a reference implementation `src/auto-reply/tokens.ts:4`.
+ * Ported VERBATIM from upstream `src/auto-reply/tokens.ts:4`.
  */
 export const SILENT_REPLY_TOKEN = 'NO_REPLY';
 

package/src/memory/mmr.ts

@@ -1,7 +1,7 @@
 /**
  * Maximal Marginal Relevance (MMR) re-ranking — Phase 2.
  *
- * Ported from a reference implementation `extensions/memory-core/src/memory/mmr.ts` with
+ * Ported from upstream `extensions/memory-core/src/memory/mmr.ts` with
  * minor adaptation for our `MemoryEntry` shape (content vs snippet, id vs
  * path+startLine). Behavior is identical: normalize scores, iteratively
  * pick the item that maximizes `λ * relevance - (1-λ) * max_similarity`
@@ -11,9 +11,9 @@
  */
 
 export interface MMRConfig {
-  /** Opt-in. Default is false. */
+  /** Opt-in. Upstream default is false. */
   enabled: boolean;
-  /** 0 = max diversity, 1 = max relevance. Default 0.7. */
+  /** 0 = max diversity, 1 = max relevance. Upstream default 0.7. */
   lambda: number;
 }
 

package/src/memory/paths.ts

@@ -8,7 +8,7 @@
  *
  * ## Why a whitelist?
  *
- * Earlier historical designs used date-keyed files
+ * Earlier upstream-faithful designs used date-keyed files
  * (`memory/YYYY-MM-DD.md`), which have three problems for a persistent
  * multi-user agent:
  *

package/src/memory/recallTracking.ts

@@ -1,9 +1,9 @@
 /**
  * Recall tracking — Phase 2.
  *
- * Lightweight adaptation of an external recall-tracking module
+ * Lightweight adaptation of upstream
  * `extensions/memory-core/src/short-term-promotion.ts::recordShortTermRecalls`.
- * The reference implementation stores recalls in a JSON file under `memory/.dreams/`; we store
+ * Upstream stores recalls in a JSON file under `memory/.dreams/`; we store
  * them in a Postgres table `agent_memory_recalls`. Schema captures what the
  * future Phase 3 dreaming/promotion algorithm will need:
  *   - which memory row was surfaced (`memory_id`)
@@ -90,7 +90,7 @@ export class PgvectorRecallTracker implements RecallTracker {
     const bucket = dayBucket(nowMs);
 
     // [recall-tracking] debug: upsert one row per (agent, memory, query, day)
-    // The reference implementation dedupes per-day per-query so repeated searches don't inflate counts.
+    // Upstream dedupes per-day per-query so repeated searches don't inflate counts.
     const values: string[] = [];
     const args: unknown[] = [];
     let i = 1;

package/src/memory/temporalDecay.ts

@@ -1,14 +1,14 @@
 /**
  * Temporal decay — Phase 2.
  *
- * Ported from a reference implementation `extensions/memory-core/src/memory/temporal-decay.ts`.
+ * Ported from upstream `extensions/memory-core/src/memory/temporal-decay.ts`.
  * Ages dated memory files (`memory/YYYY-MM-DD.md`) using exponential decay
  * `multiplier = exp(-ln(2) / halfLifeDays * ageInDays)`. At half-life, the
  * score is exactly halved.
  *
  * Evergreen files (MEMORY.md, memory/topics.md, any non-dated file inside
  * memory/) do NOT decay — they represent durable knowledge and should stay
- * hot regardless of age. This mirrors the standard `isEvergreenMemoryPath`.
+ * hot regardless of age. This mirrors upstream's `isEvergreenMemoryPath`.
  *
  * Since our pgvector rows carry `createdAt`, we don't need filesystem stat
  * fallback — the row timestamp is authoritative for any file without a

package/src/memory/types.ts

@@ -1,7 +1,7 @@
 /**
  * Autonomous memory — core types.
  *
- * Ported from the reference implementation's memory-core pattern, adapted for Postgres + pgvector
+ * Ported from upstream's memory-core pattern, adapted for Postgres + pgvector
  * and shaped so a future graph-backend layer (Graphiti, Neo4j agent-memory, etc.)
  * can be added alongside the vector store without changing the tool contracts.
  *
@@ -79,7 +79,7 @@ export interface MemorySearchOptions {
   minScore?: number;
   /**
    * Phase 2 toggles — when the backend supports them. Each is independently
-   * opt-in; all false = Phase 1 behavior.
+   * opt-in; all false = upstream Phase 1 behavior.
    */
   mmr?: { enabled?: boolean; lambda?: number };
   temporalDecay?: { enabled?: boolean; halfLifeDays?: number };
@@ -156,7 +156,7 @@ export interface MemoryConfig {
   search?: {
     maxResults?: number;
     maxInjectedChars?: number;
-    /** Phase 2 — enable MMR reranking (defaults when true). */
+    /** Phase 2 — enable MMR reranking (upstream-aligned defaults when true). */
     mmr?: { enabled?: boolean; lambda?: number };
     /** Phase 2 — enable temporal decay on dated memory files. */
     temporalDecay?: { enabled?: boolean; halfLifeDays?: number };

package/src/messages/cache.test.ts

@@ -412,14 +412,7 @@ describe('addBedrockCacheControl (Bedrock cache checkpoints)', () => {
     expect(first[1]).toEqual({ cachePoint: { type: 'default' } });
   });
 
-  it('skips system messages (cachePoint added inline by AgentContext.buildSystemRunnable)', () => {
-    /* Contract change (PR #128 alignment): system message
-     * cachePoint is now emitted inline in AgentContext.buildSystemRunnable.
-     * addBedrockCacheControl must therefore SKIP system messages so the
-     * 2-cachePoint per-request budget stays available for the conversation
-     * tail. Caching the system prefix is what unlocks cross-user cost
-     * savings — Bedrock's prompt cache is account-scoped, so a stable
-     * system prefix shared across users hits the same cache entry. */
+  it('works with the example from the langchain pr (with multi-turn behavior)', () => {
     const messages: TestMsg[] = [
       {
         role: 'system',
@@ -437,17 +430,15 @@ describe('addBedrockCacheControl (Bedrock cache checkpoints)', () => {
 
     const result = addBedrockCacheControl(messages);
 
-    const system = result[0].content as MessageContentComplex[];
-    const user = result[1].content as MessageContentComplex[];
+    let system = result[0].content as MessageContentComplex[];
+    let user = result[1].content as MessageContentComplex[];
 
-    // System message is left untouched — addBedrockCacheControl does NOT
-    // add a cachePoint here. The cachePoint is added in AgentContext when
-    // the system message is first built.
-    expect(system).toEqual([
-      { type: ContentTypes.TEXT, text: 'You\'re an advanced AI assistant.' },
-    ]);
-
-    // User message still gets a cachePoint (last eligible).
+    // Both messages get cachePoints (last 2 eligible messages)
+    expect(system[0]).toEqual({
+      type: ContentTypes.TEXT,
+      text: 'You\'re an advanced AI assistant.',
+    });
+    expect(system[1]).toEqual({ cachePoint: { type: 'default' } });
     expect(user[0]).toEqual({
       type: ContentTypes.TEXT,
       text: 'What is the capital of France?',
@@ -467,59 +458,30 @@ describe('addBedrockCacheControl (Bedrock cache checkpoints)', () => {
 
     const result2 = addBedrockCacheControl(result);
 
-    const system2 = result2[0].content as MessageContentComplex[];
-    const user2 = result2[1].content as MessageContentComplex[];
-    const assistant2 = result2[2].content as MessageContentComplex[];
+    system = result2[0].content as MessageContentComplex[];
+    user = result2[1].content as MessageContentComplex[];
+    const assistant = result2[2].content as MessageContentComplex[];
 
-    // System message still untouched.
-    expect(system2).toEqual([
-      { type: ContentTypes.TEXT, text: 'You\'re an advanced AI assistant.' },
-    ]);
+    // System message no longer has cachePoint (it's not in the last 2 eligible)
+    expect(system[0]).toEqual({
+      type: ContentTypes.TEXT,
+      text: 'You\'re an advanced AI assistant.',
+    });
+    expect(system.length).toBe(1);
 
-    // Both conversation messages now get cachePoints (last 2 eligible).
-    expect(user2[0]).toEqual({
+    // User message gets cachePoint (second-to-last eligible)
+    expect(user[0]).toEqual({
       type: ContentTypes.TEXT,
       text: 'What is the capital of France?',
     });
-    expect(user2[1]).toEqual({ cachePoint: { type: 'default' } });
+    expect(user[1]).toEqual({ cachePoint: { type: 'default' } });
 
-    expect(assistant2[0]).toEqual({
+    // Assistant message gets cachePoint (last eligible)
+    expect(assistant[0]).toEqual({
       type: ContentTypes.TEXT,
       text: 'Sure! The capital of France is Paris.',
     });
-    expect(assistant2[1]).toEqual({ cachePoint: { type: 'default' } });
-  });
-
-  it('strips stray Anthropic cache_control from system message (cross-provider safety)', () => {
-    /* If a system message arrives with an Anthropic-style cache_control
-     * marker (e.g. cross-provider switch), addBedrockCacheControl should
-     * sanitize it — Bedrock ignores cache_control and stale markers can
-     * confuse provider validation. */
-    const messages: TestMsg[] = [
-      {
-        role: 'system',
-        content: [
-          {
-            type: ContentTypes.TEXT,
-            text: 'You\'re an advanced AI assistant.',
-            cache_control: { type: 'ephemeral' },
-          } as MessageContentComplex,
-        ],
-      },
-      {
-        role: 'user',
-        content: [{ type: ContentTypes.TEXT, text: 'Hi' }],
-      },
-    ];
-
-    const result = addBedrockCacheControl(messages);
-    const system = result[0].content as MessageContentComplex[];
-
-    expect(system).toHaveLength(1);
-    expect('cache_control' in system[0]).toBe(false);
-    expect((system[0] as { text?: string }).text).toBe(
-      'You\'re an advanced AI assistant.'
-    );
+    expect(assistant[1]).toEqual({ cachePoint: { type: 'default' } });
   });
 
   it('is idempotent - calling multiple times does not add duplicate cache points', () => {