@illuma-ai/agents 1.5.1 → 2.1.1

package/src/agents/__tests__/AgentContext.test.ts

@@ -375,638 +375,6 @@ describe('AgentContext', () => {
 
       expect(ctx.instructionTokens).toBeGreaterThan(initialTokens);
     });
-
-    it('excludes deferred-undiscovered instance tools from token accounting', async () => {
-      /* Regression for #122 / #121.
-       * `calculateInstructionTokens` previously summed every entry in
-       * `this.tools` regardless of whether `getToolsForBinding` would
-       * actually emit it. That over-reported tokens and triggered
-       * spurious empty_messages preflight rejections. */
-      const deferredTool = createMockTool('deferred_tool');
-      const directTool = createMockTool('direct_tool');
-      const toolRegistry: t.LCToolRegistry = new Map([
-        [
-          'deferred_tool',
-          {
-            name: 'deferred_tool',
-            description: 'deferred',
-            defer_loading: true,
-          },
-        ],
-        [
-          'direct_tool',
-          {
-            name: 'direct_tool',
-            description: 'direct',
-          },
-        ],
-      ]);
-
-      const ctxBase = createBasicContext({
-        agentConfig: {
-          instructions: 'Test',
-          tools: [directTool],
-          toolRegistry,
-        },
-        tokenCounter: mockTokenCounter,
-      });
-      await ctxBase.calculateInstructionTokens(mockTokenCounter);
-      const baseTokens = ctxBase.getContextBreakdown().tools;
-
-      const ctxWithDeferred = createBasicContext({
-        agentConfig: {
-          instructions: 'Test',
-          tools: [directTool, deferredTool],
-          toolRegistry,
-        },
-        tokenCounter: mockTokenCounter,
-      });
-      await ctxWithDeferred.calculateInstructionTokens(mockTokenCounter);
-      const withDeferredTokens = ctxWithDeferred.getContextBreakdown().tools;
-
-      /* The deferred tool is filtered out of the bound subset, so token
-       * accounting must match the direct-only baseline. */
-      expect(withDeferredTokens).toBe(baseTokens);
-    });
-
-    it('counts deferred instance tool after discovery', async () => {
-      const deferredTool = createMockTool('deferred_tool');
-      const toolRegistry: t.LCToolRegistry = new Map([
-        [
-          'deferred_tool',
-          {
-            name: 'deferred_tool',
-            description: 'deferred',
-            defer_loading: true,
-          },
-        ],
-      ]);
-
-      const ctxUndiscovered = createBasicContext({
-        agentConfig: {
-          instructions: 'Test',
-          tools: [deferredTool],
-          toolRegistry,
-        },
-        tokenCounter: mockTokenCounter,
-      });
-      await ctxUndiscovered.calculateInstructionTokens(mockTokenCounter);
-      expect(ctxUndiscovered.getContextBreakdown().tools).toBe(0);
-
-      const ctxDiscovered = createBasicContext({
-        agentConfig: {
-          instructions: 'Test',
-          tools: [deferredTool],
-          toolRegistry,
-        },
-        tokenCounter: mockTokenCounter,
-      });
-      ctxDiscovered.markToolsAsDiscovered(['deferred_tool']);
-      await ctxDiscovered.calculateInstructionTokens(mockTokenCounter);
-      expect(ctxDiscovered.getContextBreakdown().tools).toBeGreaterThan(0);
-    });
-
-    it('excludes programmatic-only toolDefinitions from token accounting', async () => {
-      /* Programmatic-only tool definitions (allowed_callers: ['code_execution'])
-       * are never bound to the model — they were inflating toolSchemaTokens
-       * even though getEventDrivenToolsForBinding excludes them. */
-      const directDef: t.LCTool = {
-        name: 'direct_def',
-        description: 'direct schema',
-        parameters: { type: 'object', properties: {} },
-        allowed_callers: ['direct'],
-      };
-      const programmaticOnlyDef: t.LCTool = {
-        name: 'programmatic_only',
-        description: 'programmatic only schema',
-        parameters: { type: 'object', properties: {} },
-        allowed_callers: ['code_execution'],
-      };
-
-      const ctxBase = createBasicContext({
-        agentConfig: {
-          instructions: 'Test',
-          toolDefinitions: [directDef],
-        },
-        tokenCounter: mockTokenCounter,
-      });
-      await ctxBase.calculateInstructionTokens(mockTokenCounter);
-
-      const ctxWithProgrammatic = createBasicContext({
-        agentConfig: {
-          instructions: 'Test',
-          toolDefinitions: [directDef, programmaticOnlyDef],
-        },
-        tokenCounter: mockTokenCounter,
-      });
-      await ctxWithProgrammatic.calculateInstructionTokens(mockTokenCounter);
-
-      expect(ctxWithProgrammatic.getContextBreakdown().tools).toBe(
-        ctxBase.getContextBreakdown().tools
-      );
-    });
-  });
-
-  describe('System message prompt cache markers', () => {
-    /* These tests assert the contract that `buildSystemRunnable` (invoked
-     * lazily via `systemRunnable`) emits provider-specific cache markers
-     * inline in the system message. This is the cross-account / cross-user
-     * cache-hit foundation: a stable system prefix shared across all users
-     * invoking the same agent maps to the same cache entry on Anthropic
-     * (workspace-scoped) and Bedrock (account-scoped). */
-
-    const captureSystemMessage = async (ctx: AgentContext) => {
-      const runnable = ctx.systemRunnable;
-      if (!runnable) {
-        throw new Error('systemRunnable returned undefined');
-      }
-      // Invoke the prompt runnable with an empty conversation to extract
-      // the prefixed system message. RunnableLambda is async.
-      const out = (await runnable.invoke([])) as Array<{ content: unknown }>;
-      return out[0];
-    };
-
-    it('Anthropic + promptCache: stable text gets cache_control: ephemeral', async () => {
-      const ctx = AgentContext.fromConfig({
-        agentId: 'a1',
-        provider: Providers.ANTHROPIC,
-        instructions: 'Stable agent instructions',
-        clientOptions: { promptCache: true } as t.AnthropicClientOptions,
-      });
-
-      const sys = await captureSystemMessage(ctx);
-      const content = sys.content as Array<{
-        type: string;
-        text?: string;
-        cache_control?: { type: string };
-      }>;
-
-      expect(Array.isArray(content)).toBe(true);
-      expect(content).toHaveLength(1);
-      expect(content[0].type).toBe('text');
-      expect(content[0].text).toBe('Stable agent instructions');
-      expect(content[0].cache_control).toEqual({ type: 'ephemeral', ttl: '5m' });
-    });
-
-    it('Anthropic + promptCache: dynamic tail (additional_instructions) NOT marked', async () => {
-      const ctx = AgentContext.fromConfig({
-        agentId: 'a1',
-        provider: Providers.ANTHROPIC,
-        instructions: 'Stable agent instructions',
-        additional_instructions: 'Per-user dynamic context',
-        clientOptions: { promptCache: true } as t.AnthropicClientOptions,
-      });
-
-      const sys = await captureSystemMessage(ctx);
-      const content = sys.content as Array<{
-        type: string;
-        text?: string;
-        cache_control?: { type: string };
-      }>;
-
-      expect(content).toHaveLength(2);
-      expect(content[0].cache_control).toEqual({ type: 'ephemeral', ttl: '5m' });
-      expect(content[1].text).toBe('Per-user dynamic context');
-      expect(content[1].cache_control).toBeUndefined();
-    });
-
-    it('Bedrock Claude + promptCache: cachePoint inserted after stable text', async () => {
-      const ctx = AgentContext.fromConfig({
-        agentId: 'a1',
-        provider: Providers.BEDROCK,
-        instructions: 'Stable agent instructions',
-        clientOptions: {
-          promptCache: true,
-          model: 'anthropic.claude-3-5-sonnet-20241022-v2:0',
-        } as t.BedrockAnthropicClientOptions,
-      });
-
-      const sys = await captureSystemMessage(ctx);
-      const content = sys.content as Array<
-        { type: string; text?: string } | { cachePoint: { type: string } }
-      >;
-
-      expect(content).toHaveLength(2);
-      expect(content[0]).toEqual({
-        type: 'text',
-        text: 'Stable agent instructions',
-      });
-      expect(content[1]).toEqual({ cachePoint: { type: 'default', ttl: '5m' } });
-    });
-
-    it('Bedrock Claude + promptCache + dynamic: cachePoint between stable and dynamic', async () => {
-      const ctx = AgentContext.fromConfig({
-        agentId: 'a1',
-        provider: Providers.BEDROCK,
-        instructions: 'Stable agent instructions',
-        additional_instructions: 'Per-user dynamic context',
-        clientOptions: {
-          promptCache: true,
-          model: 'anthropic.claude-3-5-sonnet-20241022-v2:0',
-        } as t.BedrockAnthropicClientOptions,
-      });
-
-      const sys = await captureSystemMessage(ctx);
-      const content = sys.content as Array<
-        { type: string; text?: string } | { cachePoint: { type: string } }
-      >;
-
-      expect(content).toHaveLength(3);
-      expect((content[0] as { text: string }).text).toBe(
-        'Stable agent instructions'
-      );
-      expect(content[1]).toEqual({ cachePoint: { type: 'default', ttl: '5m' } });
-      expect((content[2] as { text: string }).text).toBe(
-        'Per-user dynamic context'
-      );
-    });
-
-    it('Bedrock Llama: NO cachePoint (model does not support it)', async () => {
-      const ctx = AgentContext.fromConfig({
-        agentId: 'a1',
-        provider: Providers.BEDROCK,
-        instructions: 'Stable agent instructions',
-        clientOptions: {
-          promptCache: true,
-          model: 'meta.llama3-1-405b-instruct-v1:0',
-        } as t.BedrockAnthropicClientOptions,
-      });
-
-      const sys = await captureSystemMessage(ctx);
-      // Falls through to plain string when neither Anthropic nor a
-      // cache-capable Bedrock model is configured.
-      expect(typeof sys.content).toBe('string');
-      expect(sys.content).toBe('Stable agent instructions');
-    });
-
-    it('Bedrock + promptCache=false: NO cachePoint', async () => {
-      const ctx = AgentContext.fromConfig({
-        agentId: 'a1',
-        provider: Providers.BEDROCK,
-        instructions: 'Stable agent instructions',
-        clientOptions: {
-          promptCache: false,
-          model: 'anthropic.claude-3-5-sonnet-20241022-v2:0',
-        } as t.BedrockAnthropicClientOptions,
-      });
-
-      const sys = await captureSystemMessage(ctx);
-      expect(typeof sys.content).toBe('string');
-    });
-
-    it('Anthropic without promptCache: plain string system content', async () => {
-      const ctx = AgentContext.fromConfig({
-        agentId: 'a1',
-        provider: Providers.ANTHROPIC,
-        instructions: 'Stable agent instructions',
-        clientOptions: { promptCache: false } as t.AnthropicClientOptions,
-      });
-
-      const sys = await captureSystemMessage(ctx);
-      expect(typeof sys.content).toBe('string');
-      expect(sys.content).toBe('Stable agent instructions');
-    });
-
-    it('Cross-user cache stability: identical agent → identical cacheable system block', async () => {
-      /* This is the load-bearing test for the cross-user cost win.
-       * Two AgentContext instances with the same agent.instructions but
-       * DIFFERENT additional_instructions (per-user dynamic context) MUST
-       * produce a byte-identical FIRST content block — the cache prefix.
-       * Bedrock and Anthropic both key the cache off the stable prefix. */
-      const baseConfig = {
-        agentId: 'a1',
-        provider: Providers.ANTHROPIC,
-        instructions: 'Stable agent instructions for ALL users',
-        clientOptions: { promptCache: true } as t.AnthropicClientOptions,
-      };
-
-      const ctxAlice = AgentContext.fromConfig({
-        ...baseConfig,
-        additional_instructions: 'Hi Alice. Memory: A, B, C.',
-      });
-      const ctxBob = AgentContext.fromConfig({
-        ...baseConfig,
-        additional_instructions: 'Hi Bob. Memory: X, Y, Z.',
-      });
-
-      const sysAlice = await captureSystemMessage(ctxAlice);
-      const sysBob = await captureSystemMessage(ctxBob);
-
-      const contentAlice = sysAlice.content as Array<{
-        type: string;
-        text: string;
-        cache_control?: { type: string };
-      }>;
-      const contentBob = sysBob.content as Array<{
-        type: string;
-        text: string;
-        cache_control?: { type: string };
-      }>;
-
-      // Stable prefix is BYTE-IDENTICAL → same cache entry.
-      expect(contentAlice[0]).toEqual(contentBob[0]);
-
-      // Dynamic tail differs but is NOT cache-marked.
-      expect(contentAlice[1].text).not.toBe(contentBob[1].text);
-      expect(contentAlice[1].cache_control).toBeUndefined();
-      expect(contentBob[1].cache_control).toBeUndefined();
-    });
-  });
-
-  describe('System cache blocks (multi-cachePoint emission)', () => {
-    /* Verifies the generic multi-cachePoint primitive. Consumers compose
-     * cacheable blocks via `system_cache_blocks` and the library encodes
-     * provider-specific cache markers around each. See
-     * src/types/agent-cache.ts for the contract. */
-
-    const captureSystemMessage = async (ctx: AgentContext) => {
-      const runnable = ctx.systemRunnable;
-      if (!runnable) {
-        throw new Error('systemRunnable returned undefined');
-      }
-      const out = (await runnable.invoke([])) as Array<{ content: unknown }>;
-      return out[0];
-    };
-
-    it('Anthropic with one cache block + instructions + dynamic: emits 3 cache_control blocks', async () => {
-      const ctx = AgentContext.fromConfig({
-        agentId: 'a1',
-        provider: Providers.ANTHROPIC,
-        system_cache_blocks: [{ text: 'Outer cacheable prefix.' }],
-        instructions: 'Agent-specific stable.',
-        additional_instructions: 'Dynamic per-user.',
-        clientOptions: { promptCache: true } as t.AnthropicClientOptions,
-      });
-
-      const sys = await captureSystemMessage(ctx);
-      const content = sys.content as Array<{
-        type: string;
-        text: string;
-        cache_control?: { type: string; ttl?: string };
-      }>;
-
-      expect(content).toHaveLength(3);
-      expect(content[0].text).toBe('Outer cacheable prefix.');
-      expect(content[0].cache_control).toEqual({
-        type: 'ephemeral',
-        ttl: '5m',
-      });
-      expect(content[1].text).toBe('Agent-specific stable.');
-      expect(content[1].cache_control).toEqual({
-        type: 'ephemeral',
-        ttl: '5m',
-      });
-      expect(content[2].text).toBe('Dynamic per-user.');
-      expect(content[2].cache_control).toBeUndefined();
-    });
-
-    it('Bedrock with one cache block + instructions + dynamic: emits 5-element content array', async () => {
-      const ctx = AgentContext.fromConfig({
-        agentId: 'a1',
-        provider: Providers.BEDROCK,
-        system_cache_blocks: [{ text: 'Outer cacheable prefix.' }],
-        instructions: 'Agent-specific stable.',
-        additional_instructions: 'Dynamic per-user.',
-        clientOptions: {
-          promptCache: true,
-          model: 'anthropic.claude-3-5-sonnet-20241022-v2:0',
-        } as t.BedrockAnthropicClientOptions,
-      });
-
-      const sys = await captureSystemMessage(ctx);
-      const content = sys.content as Array<
-        | { type: string; text: string }
-        | { cachePoint: { type: string; ttl?: string } }
-      >;
-
-      expect(content).toHaveLength(5);
-      expect((content[0] as { text: string }).text).toBe('Outer cacheable prefix.');
-      expect(content[1]).toEqual({ cachePoint: { type: 'default', ttl: '5m' } });
-      expect((content[2] as { text: string }).text).toBe(
-        'Agent-specific stable.'
-      );
-      expect(content[3]).toEqual({ cachePoint: { type: 'default', ttl: '5m' } });
-      expect((content[4] as { text: string }).text).toBe('Dynamic per-user.');
-    });
-
-    it('per-block TTL respected: prefix=5m, instructions=1h emits the right TTL on each cachePoint', async () => {
-      const ctx = AgentContext.fromConfig({
-        agentId: 'a1',
-        provider: Providers.BEDROCK,
-        system_cache_blocks: [{ text: 'Prefix.', ttl: '5m' }],
-        instructions: 'Agent.',
-        instructions_cache_ttl: '1h',
-        clientOptions: {
-          promptCache: true,
-          model: 'anthropic.claude-3-5-sonnet-20241022-v2:0',
-        } as t.BedrockAnthropicClientOptions,
-      });
-
-      const sys = await captureSystemMessage(ctx);
-      const content = sys.content as Array<
-        | { type: string; text: string }
-        | { cachePoint: { type: string; ttl?: string } }
-      >;
-
-      expect(content).toHaveLength(4);
-      expect(content[1]).toEqual({ cachePoint: { type: 'default', ttl: '5m' } });
-      expect(content[3]).toEqual({ cachePoint: { type: 'default', ttl: '1h' } });
-    });
-
-    it('Cross-tenant cache stability: two consumers with shared cache block produce byte-identical prefix', async () => {
-      /* Load-bearing test: two distinct agents (different instructions)
-       * but the SAME outer cache block produce byte-identical first
-       * content entries, so Bedrock/Anthropic see the same cache key for
-       * the outer block. */
-      const sharedPrefix = 'Universal platform identity rules and tool routing.';
-
-      const customAgentA = AgentContext.fromConfig({
-        agentId: 'finance-helper',
-        name: 'Finance Helper',
-        provider: Providers.BEDROCK,
-        system_cache_blocks: [{ text: sharedPrefix }],
-        instructions: 'You are Finance Helper. Use SAP and Bloomberg.',
-        clientOptions: {
-          promptCache: true,
-          model: 'anthropic.claude-3-5-sonnet-20241022-v2:0',
-        } as t.BedrockAnthropicClientOptions,
-      });
-
-      const customAgentB = AgentContext.fromConfig({
-        agentId: 'hr-helper',
-        name: 'HR Helper',
-        provider: Providers.BEDROCK,
-        system_cache_blocks: [{ text: sharedPrefix }],
-        instructions: 'You are HR Helper. Use Workday and Lever.',
-        clientOptions: {
-          promptCache: true,
-          model: 'anthropic.claude-3-5-sonnet-20241022-v2:0',
-        } as t.BedrockAnthropicClientOptions,
-      });
-
-      const sysA = await captureSystemMessage(customAgentA);
-      const sysB = await captureSystemMessage(customAgentB);
-      const contentA = sysA.content as Array<unknown>;
-      const contentB = sysB.content as Array<unknown>;
-
-      // First TWO entries must match byte-for-byte: [prefix text, cachePoint]
-      expect(contentA[0]).toEqual(contentB[0]);
-      expect(contentA[1]).toEqual(contentB[1]);
-
-      // Third entry (agent-specific text) MUST differ — they are different agents.
-      expect(contentA[2]).not.toEqual(contentB[2]);
-    });
-
-    it('Empty system_cache_blocks: falls back to 2-tier (instructions + dynamic) shape', async () => {
-      /* Backwards-compat: consumers without the multi-cachePoint pattern
-       * get the legacy 2-tier shape — instructions + dynamic. */
-      const ctx = AgentContext.fromConfig({
-        agentId: 'a1',
-        provider: Providers.BEDROCK,
-        instructions: 'Agent-only stable.',
-        additional_instructions: 'Dynamic per-user.',
-        clientOptions: {
-          promptCache: true,
-          model: 'anthropic.claude-3-5-sonnet-20241022-v2:0',
-        } as t.BedrockAnthropicClientOptions,
-      });
-
-      const sys = await captureSystemMessage(ctx);
-      const content = sys.content as Array<unknown>;
-
-      // [text, cachePoint, text] — exactly the 2-tier shape
-      expect(content).toHaveLength(3);
-      expect((content[0] as { text: string }).text).toBe('Agent-only stable.');
-      expect(content[1]).toEqual({ cachePoint: { type: 'default', ttl: '5m' } });
-      expect((content[2] as { text: string }).text).toBe('Dynamic per-user.');
-    });
-
-    it('Cache block only (no instructions): emits prefix tier + dynamic', async () => {
-      /* Edge case: only system_cache_blocks set, instructions empty.
-       * Useful for "global default" agents that rely entirely on the
-       * shared cacheable prefix. */
-      const ctx = AgentContext.fromConfig({
-        agentId: 'a1',
-        provider: Providers.BEDROCK,
-        system_cache_blocks: [{ text: 'Prefix only.' }],
-        additional_instructions: 'Dynamic.',
-        clientOptions: {
-          promptCache: true,
-          model: 'anthropic.claude-3-5-sonnet-20241022-v2:0',
-        } as t.BedrockAnthropicClientOptions,
-      });
-
-      const sys = await captureSystemMessage(ctx);
-      const content = sys.content as Array<unknown>;
-
-      // [prefix text, cachePoint, dynamic text]
-      expect(content).toHaveLength(3);
-      expect((content[0] as { text: string }).text).toBe('Prefix only.');
-      expect(content[1]).toEqual({ cachePoint: { type: 'default', ttl: '5m' } });
-      expect((content[2] as { text: string }).text).toBe('Dynamic.');
-    });
-
-    it('two cache blocks: emits 2 cachePoints in order', async () => {
-      /* Composite case — N=2 entries. Each gets its own cachePoint, in
-       * declared order (outer first). This proves the array semantics. */
-      const ctx = AgentContext.fromConfig({
-        agentId: 'a1',
-        provider: Providers.BEDROCK,
-        system_cache_blocks: [
-          { text: 'Block A (outer).', ttl: '1h' },
-          { text: 'Block B (inner).', ttl: '5m' },
-        ],
-        instructions: 'Instructions.',
-        clientOptions: {
-          promptCache: true,
-          model: 'anthropic.claude-3-5-sonnet-20241022-v2:0',
-        } as t.BedrockAnthropicClientOptions,
-      });
-
-      const sys = await captureSystemMessage(ctx);
-      const content = sys.content as Array<
-        | { type: string; text: string }
-        | { cachePoint: { type: string; ttl?: string } }
-      >;
-
-      // [A text, cp(1h), B text, cp(5m), instructions text, cp(5m)]
-      expect(content).toHaveLength(6);
-      expect((content[0] as { text: string }).text).toBe('Block A (outer).');
-      expect(content[1]).toEqual({ cachePoint: { type: 'default', ttl: '1h' } });
-      expect((content[2] as { text: string }).text).toBe('Block B (inner).');
-      expect(content[3]).toEqual({ cachePoint: { type: 'default', ttl: '5m' } });
-      expect((content[4] as { text: string }).text).toBe('Instructions.');
-      expect(content[5]).toEqual({ cachePoint: { type: 'default', ttl: '5m' } });
-    });
-
-    it('throws when system_cache_blocks exceeds MAX_SYSTEM_CACHE_BLOCKS (cachePoint budget)', () => {
-      /* Bedrock supports 4 cachePoints/request total. The library uses up
-       * to 2 in the system message + 1 trailing for instructions, leaving
-       * 1 for the tools array. Allowing 3+ entries would silently exceed
-       * the budget — the library throws to surface the misuse early. */
-      expect(() => {
-        AgentContext.fromConfig({
-          agentId: 'a1',
-          provider: Providers.BEDROCK,
-          system_cache_blocks: [
-            { text: 'A' },
-            { text: 'B' },
-            { text: 'C' }, // ← over the cap
-          ],
-          instructions: 'X',
-          clientOptions: {
-            promptCache: true,
-            model: 'anthropic.claude-3-5-sonnet-20241022-v2:0',
-          } as t.BedrockAnthropicClientOptions,
-        });
-      }).toThrow(/system_cache_blocks supports at most 2 entries/);
-    });
-
-    it('Bedrock with non-cache-supported model (titan): NO cachePoint emitted', async () => {
-      /* The cacheSupport allowlist (cacheSupport.ts) rejects titan — we
-       * must NOT emit cachePoint markers there or Bedrock errors. */
-      const ctx = AgentContext.fromConfig({
-        agentId: 'a1',
-        provider: Providers.BEDROCK,
-        system_cache_blocks: [{ text: 'Prefix.' }],
-        instructions: 'Agent.',
-        clientOptions: {
-          promptCache: true,
-          model: 'amazon.titan-text-premier-v1:0',
-        } as t.BedrockAnthropicClientOptions,
-      });
-
-      const sys = await captureSystemMessage(ctx);
-      // Falls through to plain string concatenation when caching unsupported.
-      expect(typeof sys.content).toBe('string');
-    });
-
-    it('Bedrock with bedrockCacheModelPatterns extension: emits cachePoint for custom model', async () => {
-      /* Consumer extension: AWS adds a new model family before the
-       * library's allowlist updates. Consumer passes a regex; library
-       * treats the model as cache-supported. */
-      const ctx = AgentContext.fromConfig({
-        agentId: 'a1',
-        provider: Providers.BEDROCK,
-        system_cache_blocks: [{ text: 'Prefix.' }],
-        instructions: 'Agent.',
-        clientOptions: {
-          promptCache: true,
-          model: 'mycorp.future-model-v1:0',
-          bedrockCacheModelPatterns: [/^mycorp\.future-model-/i],
-        } as t.BedrockAnthropicClientOptions & {
-          bedrockCacheModelPatterns?: readonly RegExp[];
-        },
-      });
-
-      const sys = await captureSystemMessage(ctx);
-      const content = sys.content as Array<unknown>;
-
-      expect(Array.isArray(content)).toBe(true);
-      expect(content).toContainEqual({
-        cachePoint: { type: 'default', ttl: '5m' },
-      });
-    });
   });
 
   describe('reset()', () => {

package/src/common/__tests__/enum.test.ts

@@ -22,7 +22,7 @@ describe('EdgeType enum', () => {
     expect(EdgeType.HANDOFF).toBe('handoff');
   });
 
-  it('has correct DIRECT value (fixed graph edges, consumers may layer fan-in / parallel / approval-gate logic)', () => {
+  it('has correct DIRECT value (fixed graph edges with Ranger fan-in / parallel / approval-gate logic)', () => {
     expect(EdgeType.DIRECT).toBe('direct');
   });