@illuma-ai/agents 1.5.1 → 2.1.1

package/src/llm/anthropic/utils/server-tool-inputs.test.ts

@@ -1,436 +0,0 @@
-/* eslint-disable @typescript-eslint/no-explicit-any */
-import { AIMessage, HumanMessage, ToolMessage } from '@langchain/core/messages';
-import type { BaseMessage } from '@langchain/core/messages';
-import { _convertMessagesToAnthropicPayload } from './message_inputs';
-
-describe('_convertMessagesToAnthropicPayload — server tool use (web search) multi-turn', () => {
-  /* Skipped: this fork intentionally diverged from the reference implementation's
-   * `_convertLangChainToolCallToAnthropic` — local always emits
-   * `tool_use` regardless of `srvtoolu_` ID prefix (see message_inputs.ts
-   * line ~144). These tests assert the standard server_tool_use emission
-   * which this fork does not implement. The text→server_tool_use correction
-   * test (next, "corrects text-typed server tool blocks") still passes
-   * because that path lives in `_formatContent`. */
-  it.skip('corrects tool_use blocks with srvtoolu_ IDs to server_tool_use', () => {
-    const messageHistory: BaseMessage[] = [
-      new HumanMessage('search for X and Y'),
-      new AIMessage({
-        content: [
-          { type: 'text', text: 'I will search for that.' },
-          {
-            type: 'tool_use',
-            id: 'srvtoolu_1',
-            name: 'web_search',
-            input: { query: 'X' },
-          },
-          {
-            type: 'web_search_tool_result',
-            tool_use_id: 'srvtoolu_1',
-            content: [
-              {
-                type: 'web_search_result',
-                url: 'https://example.com',
-                title: 'Result',
-                encrypted_content: 'abc',
-                page_age: '1d',
-              },
-            ],
-          },
-          {
-            type: 'tool_use',
-            id: 'srvtoolu_2',
-            name: 'web_search',
-            input: { query: 'Y' },
-          },
-          {
-            type: 'web_search_tool_result',
-            tool_use_id: 'srvtoolu_2',
-            content: [
-              {
-                type: 'web_search_result',
-                url: 'https://example2.com',
-                title: 'Result 2',
-                encrypted_content: 'def',
-                page_age: '2d',
-              },
-            ],
-          },
-          { type: 'text', text: 'Here are the results.' },
-        ],
-        tool_calls: [
-          {
-            id: 'srvtoolu_1',
-            name: 'web_search',
-            args: { query: 'X' },
-            type: 'tool_call',
-          },
-          {
-            id: 'srvtoolu_2',
-            name: 'web_search',
-            args: { query: 'Y' },
-            type: 'tool_call',
-          },
-        ],
-      }),
-      new HumanMessage('follow up question'),
-    ];
-
-    const { messages } = _convertMessagesToAnthropicPayload(messageHistory);
-    expect(messages).toHaveLength(3);
-
-    const assistantContent = messages[1].content as any[];
-    const serverToolBlocks = assistantContent.filter(
-      (b: any) => b.type === 'server_tool_use'
-    );
-    const searchResultBlocks = assistantContent.filter(
-      (b: any) => b.type === 'web_search_tool_result'
-    );
-    const regularToolUseBlocks = assistantContent.filter(
-      (b: any) => b.type === 'tool_use' && b.id?.startsWith('srvtoolu_')
-    );
-
-    expect(serverToolBlocks).toHaveLength(2);
-    expect(searchResultBlocks).toHaveLength(2);
-    expect(regularToolUseBlocks).toHaveLength(0);
-
-    // Verify blocks are clean (no extra streaming properties)
-    for (const b of serverToolBlocks) {
-      expect(Object.keys(b).sort()).toEqual(
-        ['id', 'input', 'name', 'type'].sort()
-      );
-    }
-    for (const b of searchResultBlocks) {
-      expect(Object.keys(b).sort()).toEqual(
-        ['content', 'tool_use_id', 'type'].sort()
-      );
-    }
-  });
-
-  it('corrects text-typed server tool blocks back to correct types', () => {
-    const messageHistory: BaseMessage[] = [
-      new HumanMessage('search for X'),
-      new AIMessage({
-        content: [
-          {
-            type: 'text',
-            id: 'srvtoolu_1',
-            name: 'web_search',
-            input: '{"query":"X"}',
-          },
-          {
-            type: 'text',
-            tool_use_id: 'srvtoolu_1',
-            content: [
-              {
-                type: 'web_search_result',
-                url: 'https://example.com',
-                title: 'Result',
-                encrypted_content: 'abc',
-                page_age: '1d',
-              },
-            ],
-          },
-          { type: 'text', text: 'Found results.' },
-        ],
-        tool_calls: [
-          {
-            id: 'srvtoolu_1',
-            name: 'web_search',
-            args: { query: 'X' },
-            type: 'tool_call',
-          },
-        ],
-      }),
-      new HumanMessage('follow up'),
-    ];
-
-    const { messages } = _convertMessagesToAnthropicPayload(messageHistory);
-    const assistantContent = messages[1].content as any[];
-
-    expect(assistantContent[0]).toEqual({
-      type: 'server_tool_use',
-      id: 'srvtoolu_1',
-      name: 'web_search',
-      input: { query: 'X' },
-    });
-    expect(assistantContent[1].type).toBe('web_search_tool_result');
-    expect(assistantContent[1].tool_use_id).toBe('srvtoolu_1');
-    expect(assistantContent[2]).toEqual({
-      type: 'text',
-      text: 'Found results.',
-    });
-  });
-
-  /* Skipped: depends on the standard server_tool_use emission, see header. */
-  it.skip('filters server tool calls when content is a string', () => {
-    const messageHistory: BaseMessage[] = [
-      new HumanMessage('search for X'),
-      new AIMessage({
-        content: 'I searched and found results.',
-        tool_calls: [
-          {
-            id: 'srvtoolu_1',
-            name: 'web_search',
-            args: { query: 'X' },
-            type: 'tool_call',
-          },
-          {
-            id: 'toolu_regular',
-            name: 'calculator',
-            args: { expr: '2+2' },
-            type: 'tool_call',
-          },
-        ],
-      }),
-      new ToolMessage({
-        content: '4',
-        tool_call_id: 'toolu_regular',
-      }),
-      new HumanMessage('follow up'),
-    ];
-
-    const { messages } = _convertMessagesToAnthropicPayload(messageHistory);
-    const assistantContent = messages[1].content as any[];
-
-    const toolUseBlocks = assistantContent.filter(
-      (b: any) => b.type === 'tool_use'
-    );
-    expect(toolUseBlocks).toHaveLength(1);
-    expect(toolUseBlocks[0].id).toBe('toolu_regular');
-
-    const serverToolBlocks = assistantContent.filter((b: any) =>
-      b.id?.startsWith('srvtoolu_')
-    );
-    expect(serverToolBlocks).toHaveLength(0);
-  });
-
-  /* Skipped: depends on the standard server_tool_use emission, see header. */
-  it.skip('handles empty string content with only server tool calls', () => {
-    const messageHistory: BaseMessage[] = [
-      new HumanMessage('search for X'),
-      new AIMessage({
-        content: '',
-        tool_calls: [
-          {
-            id: 'srvtoolu_1',
-            name: 'web_search',
-            args: { query: 'X' },
-            type: 'tool_call',
-          },
-        ],
-      }),
-      new HumanMessage('follow up'),
-    ];
-
-    const { messages } = _convertMessagesToAnthropicPayload(messageHistory);
-    const assistantContent = messages[1].content as any[];
-    expect(assistantContent).toHaveLength(1);
-    expect(assistantContent[0].type).toBe('text');
-    expect(assistantContent[0].text).toBe(' ');
-  });
-
-  /* Skipped: depends on the standard server_tool_use emission, see header. */
-  it.skip('preserves regular tool_use blocks alongside corrected server tool blocks', () => {
-    const messageHistory: BaseMessage[] = [
-      new HumanMessage('search for X and calculate 2+2'),
-      new AIMessage({
-        content: [
-          { type: 'text', text: 'Let me help.' },
-          {
-            type: 'tool_use',
-            id: 'srvtoolu_1',
-            name: 'web_search',
-            input: { query: 'X' },
-          },
-          {
-            type: 'web_search_tool_result',
-            tool_use_id: 'srvtoolu_1',
-            content: [
-              {
-                type: 'web_search_result',
-                url: 'https://example.com',
-                title: 'Result',
-                encrypted_content: 'abc',
-                page_age: '1d',
-              },
-            ],
-          },
-          {
-            type: 'tool_use',
-            id: 'toolu_calc',
-            name: 'calculator',
-            input: { expr: '2+2' },
-          },
-        ],
-        tool_calls: [
-          {
-            id: 'srvtoolu_1',
-            name: 'web_search',
-            args: { query: 'X' },
-            type: 'tool_call',
-          },
-          {
-            id: 'toolu_calc',
-            name: 'calculator',
-            args: { expr: '2+2' },
-            type: 'tool_call',
-          },
-        ],
-      }),
-      new ToolMessage({
-        content: '4',
-        tool_call_id: 'toolu_calc',
-      }),
-      new HumanMessage('follow up'),
-    ];
-
-    const { messages } = _convertMessagesToAnthropicPayload(messageHistory);
-    const assistantContent = messages[1].content as any[];
-
-    const serverToolUse = assistantContent.filter(
-      (b: any) => b.type === 'server_tool_use'
-    );
-    const webSearchResult = assistantContent.filter(
-      (b: any) => b.type === 'web_search_tool_result'
-    );
-    const regularToolUse = assistantContent.filter(
-      (b: any) => b.type === 'tool_use' && !b.id?.startsWith('srvtoolu_')
-    );
-
-    expect(serverToolUse).toHaveLength(1);
-    expect(serverToolUse[0].id).toBe('srvtoolu_1');
-    expect(webSearchResult).toHaveLength(1);
-    expect(regularToolUse).toHaveLength(1);
-    expect(regularToolUse[0].id).toBe('toolu_calc');
-  });
-
-  it('filters out empty text blocks from array content', () => {
-    const messageHistory: BaseMessage[] = [
-      new HumanMessage('search for X'),
-      new AIMessage({
-        content: [
-          { type: 'text', text: '' },
-          {
-            type: 'server_tool_use',
-            id: 'srvtoolu_1',
-            name: 'web_search',
-            input: { query: 'X' },
-          },
-          {
-            type: 'web_search_tool_result',
-            tool_use_id: 'srvtoolu_1',
-            content: [
-              {
-                type: 'web_search_result',
-                url: 'https://example.com',
-                title: 'Result',
-                encrypted_content: 'abc',
-                page_age: '1d',
-              },
-            ],
-          },
-          { type: 'text', text: '' },
-          { type: 'text', text: 'Here are the results.' },
-        ],
-        tool_calls: [
-          {
-            id: 'srvtoolu_1',
-            name: 'web_search',
-            args: { query: 'X' },
-            type: 'tool_call',
-          },
-        ],
-      }),
-      new HumanMessage('follow up'),
-    ];
-
-    const { messages } = _convertMessagesToAnthropicPayload(messageHistory);
-    const assistantContent = messages[1].content as any[];
-
-    const emptyTextBlocks = assistantContent.filter(
-      (b: any) => b.type === 'text' && b.text === ''
-    );
-    expect(emptyTextBlocks).toHaveLength(0);
-
-    const textBlocks = assistantContent.filter((b: any) => b.type === 'text');
-    expect(textBlocks).toHaveLength(1);
-    expect(textBlocks[0].text).toBe('Here are the results.');
-  });
-
-  /**
-   * Regression for discussion #12806.
-   *
-   * Anthropic web_search responses can include text blocks whose text is
-   * whitespace-only (e.g. ' ', '\n', '\t') alongside server_tool_use and
-   * web_search_tool_result blocks. On follow-up turns the API rejects these
-   * with: "messages: text content blocks must contain non-whitespace text".
-   *
-   * The empty-string check alone is insufficient — the filter must drop any
-   * text block whose trimmed content is empty.
-   */
-  it.each([
-    ['single space', ' '],
-    ['newline', '\n'],
-    ['tab', '\t'],
-    ['multiple spaces', '   '],
-    ['mixed whitespace', ' \n\t '],
-  ])(
-    'filters whitespace-only text blocks from array content (%s)',
-    (_label, whitespace) => {
-      const messageHistory: BaseMessage[] = [
-        new HumanMessage('search for X'),
-        new AIMessage({
-          content: [
-            { type: 'text', text: whitespace },
-            {
-              type: 'server_tool_use',
-              id: 'srvtoolu_1',
-              name: 'web_search',
-              input: { query: 'X' },
-            },
-            {
-              type: 'web_search_tool_result',
-              tool_use_id: 'srvtoolu_1',
-              content: [
-                {
-                  type: 'web_search_result',
-                  url: 'https://example.com',
-                  title: 'Result',
-                  encrypted_content: 'abc',
-                  page_age: '1d',
-                },
-              ],
-            },
-            { type: 'text', text: 'Here are the results.' },
-          ],
-          tool_calls: [
-            {
-              id: 'srvtoolu_1',
-              name: 'web_search',
-              args: { query: 'X' },
-              type: 'tool_call',
-            },
-          ],
-        }),
-        new HumanMessage('follow up'),
-      ];
-
-      const { messages } = _convertMessagesToAnthropicPayload(messageHistory);
-      const assistantContent = messages[1].content as any[];
-
-      const whitespaceTextBlocks = assistantContent.filter(
-        (b: any) =>
-          b.type === 'text' &&
-          typeof b.text === 'string' &&
-          b.text.trim() === ''
-      );
-      expect(whitespaceTextBlocks).toHaveLength(0);
-
-      const textBlocks = assistantContent.filter(
-        (b: any) => b.type === 'text'
-      );
-      expect(textBlocks).toHaveLength(1);
-      expect(textBlocks[0].text).toBe('Here are the results.');
-    }
-  );
-});

package/src/llm/bedrock/cacheSupport.test.ts

@@ -1,99 +0,0 @@
-import {
-  DEFAULT_BEDROCK_CACHE_MODEL_PATTERNS,
-  isBedrockCacheSupported,
-} from './cacheSupport';
-
-describe('isBedrockCacheSupported', () => {
-  describe('default allowlist — supported models', () => {
-    const supported = [
-      // Anthropic Claude direct
-      'anthropic.claude-3-5-sonnet-20241022-v2:0',
-      'anthropic.claude-3-haiku-20240307-v1:0',
-      'anthropic.claude-opus-4-5-20250514-v1:0',
-      'anthropic.claude-sonnet-4-5-20250929-v1:0',
-      // Anthropic Claude via cross-region inference profile
-      'us.anthropic.claude-sonnet-4-5-20250929-v1:0',
-      'us.anthropic.claude-haiku-4-5-20251001-v1:0',
-      'eu.anthropic.claude-3-5-sonnet-20241022-v2:0',
-      // Amazon Nova
-      'amazon.nova-pro-v1:0',
-      'amazon.nova-lite-v1:0',
-      'amazon.nova-canvas-v1:0',
-      'us.amazon.nova-pro-v1:0',
-    ];
-
-    for (const model of supported) {
-      it(`accepts "${model}"`, () => {
-        expect(isBedrockCacheSupported(model)).toBe(true);
-      });
-    }
-  });
-
-  describe('default allowlist — unsupported models', () => {
-    const unsupported = [
-      'amazon.titan-text-premier-v1:0',
-      'amazon.titan-embed-text-v2:0',
-      'meta.llama3-1-405b-instruct-v1:0',
-      'meta.llama3-2-90b-instruct-v1:0',
-      'cohere.command-r-plus-v1:0',
-      'mistral.mistral-large-2402-v1:0',
-      'ai21.j2-ultra-v1',
-      'stability.sd3-5-large-v1:0',
-      // Adversarial — substring match would falsely accept these
-      'meta.llama-claude-killer-v1', // contains "claude" but isn't an Anthropic model
-      'fake.anthropic-impersonator', // contains "anthropic" but wrong vendor
-    ];
-
-    for (const model of unsupported) {
-      it(`rejects "${model}"`, () => {
-        expect(isBedrockCacheSupported(model)).toBe(false);
-      });
-    }
-  });
-
-  describe('edge cases', () => {
-    it('returns false for undefined', () => {
-      expect(isBedrockCacheSupported(undefined)).toBe(false);
-    });
-
-    it('returns false for empty string', () => {
-      expect(isBedrockCacheSupported('')).toBe(false);
-    });
-  });
-
-  describe('consumer extension via additionalPatterns', () => {
-    it('accepts model matching consumer-supplied pattern', () => {
-      expect(
-        isBedrockCacheSupported('mycorp.future-model-v1:0', [
-          /^mycorp\.future-/i,
-        ]),
-      ).toBe(true);
-    });
-
-    it('still rejects models not in default OR consumer allowlist', () => {
-      expect(
-        isBedrockCacheSupported('cohere.command-r-plus-v1:0', [
-          /^mycorp\./i,
-        ]),
-      ).toBe(false);
-    });
-
-    it('default allowlist still works alongside extensions', () => {
-      // Both default + custom pattern work
-      expect(
-        isBedrockCacheSupported('anthropic.claude-3-haiku-20240307-v1:0', [
-          /^mycorp\./i,
-        ]),
-      ).toBe(true);
-    });
-  });
-
-  describe('DEFAULT_BEDROCK_CACHE_MODEL_PATTERNS export', () => {
-    it('is a non-empty readonly array of RegExp', () => {
-      expect(DEFAULT_BEDROCK_CACHE_MODEL_PATTERNS.length).toBeGreaterThan(0);
-      for (const pattern of DEFAULT_BEDROCK_CACHE_MODEL_PATTERNS) {
-        expect(pattern).toBeInstanceOf(RegExp);
-      }
-    });
-  });
-});

package/src/llm/bedrock/cacheSupport.ts

@@ -1,53 +0,0 @@
-/**
- * Bedrock prompt-cache model support detection.
- * ===============================================
- *
- * Bedrock prompt caching (via `cachePoint` blocks) is only supported on
- * specific model families. Other families silently reject or ignore the
- * markers. We maintain an allowlist instead of a substring heuristic so
- * a future model with an unfortunate name (e.g. `llama-claude-killer`)
- * doesn't accidentally match.
- *
- * Consumers can extend the allowlist with `bedrockCacheModelPatterns` in
- * `clientOptions` for proprietary or pre-release model IDs not yet in
- * the reference library.
- */
-
-/**
- * Default allowlist of Bedrock model ID patterns that support cachePoint.
- * Sourced from AWS Bedrock documentation (verified against us-east-1
- * 2026-05).
- *
- * Adding a new model: append a RegExp here AND add a regression test in
- * `cacheSupport.test.ts` covering at least one full model ID for that
- * family. Removing a model: do not remove without operator confirmation
- * — silent removal would suddenly stop emitting cachePoint markers and
- * regress cost savings.
- */
-export const DEFAULT_BEDROCK_CACHE_MODEL_PATTERNS: readonly RegExp[] = [
-  // Anthropic Claude family (anthropic.claude-* and us.anthropic.claude-*)
-  /(?:^|[/.])anthropic\.claude-/i,
-  /(?:^|\.)us\.anthropic\.claude-/i,
-  // Amazon Nova family (nova-pro, nova-lite, nova-canvas, etc.)
-  /(?:^|[/.])amazon\.nova-/i,
-  /(?:^|\.)us\.amazon\.nova-/i,
-];
-
-/**
- * Returns true when the given Bedrock model ID belongs to a family that
- * supports cachePoint blocks. `additionalPatterns` lets consumers extend
- * the allowlist for models the library doesn't know about yet.
- *
- * @param modelId  Bedrock model ID (e.g. `us.anthropic.claude-sonnet-4-5-20250929-v1:0`)
- * @param additionalPatterns  Extra patterns from consumer config
- */
-export function isBedrockCacheSupported(
-  modelId: string | undefined,
-  additionalPatterns?: readonly RegExp[],
-): boolean {
-  if (!modelId) return false;
-  const allPatterns = additionalPatterns
-    ? [...DEFAULT_BEDROCK_CACHE_MODEL_PATTERNS, ...additionalPatterns]
-    : DEFAULT_BEDROCK_CACHE_MODEL_PATTERNS;
-  return allPatterns.some((p) => p.test(modelId));
-}