@illuma-ai/agents 1.4.0-alpha.6 → 1.5.1

package/src/tools/search/test.ts

@@ -1,159 +0,0 @@
-/* eslint-disable no-console */
-// processWikipedia.ts
-import * as fs from 'fs';
-import * as path from 'path';
-import { processContent } from './content';
-
-/**
- * Process a Wikipedia article (HTML and Markdown) and create a referenced version
- */
-async function processWikipediaArticle(): Promise<void> {
-  try {
-    console.log('Starting Wikipedia article processing...');
-
-    // Define file paths - adapt these to your specific file locations
-    const htmlPath = path.resolve('./test.html');
-    const markdownPath = path.resolve('./test.md');
-    const outputPath = path.resolve('./output.md');
-
-    // Check if input files exist
-    if (!fs.existsSync(htmlPath)) {
-      throw new Error(`Wikipedia HTML file not found at ${htmlPath}`);
-    }
-
-    if (!fs.existsSync(markdownPath)) {
-      throw new Error(`Wikipedia Markdown file not found at ${markdownPath}`);
-    }
-
-    console.log('Reading Wikipedia article files...');
-    const html = fs.readFileSync(htmlPath, 'utf-8');
-    const markdown = fs.readFileSync(markdownPath, 'utf-8');
-
-    // Extract article title for logging
-    const titleMatch = /<h1[^>]*>([^<]+)<\/h1>/i.exec(html);
-    const articleTitle = titleMatch
-      ? titleMatch[1].trim()
-      : 'Wikipedia article';
-
-    console.log(`Processing "${articleTitle}"...`);
-
-    // Measure processing time
-    const startTime = process.hrtime();
-
-    // Process content
-    const result = processContent(html, markdown);
-
-    // Calculate processing time
-    const elapsed = process.hrtime(startTime);
-    const timeInMs = elapsed[0] * 1000 + elapsed[1] / 1000000;
-
-    // Generate reference appendix
-    const appendix = generateReferenceAppendix(result);
-
-    // Create complete output with the processed content and appendix
-    const completeOutput = result.markdown + appendix;
-
-    // Write to output file
-    fs.writeFileSync(outputPath, completeOutput);
-
-    // Print processing statistics
-    console.log('\nWikipedia article processing complete! ✓');
-    console.log('-'.repeat(60));
-    console.log(`Article: ${articleTitle}`);
-    console.log(`Processing time: ${timeInMs.toFixed(2)}ms`);
-    console.log('Media references replaced:');
-    console.log(`  - Links: ${result.links.length}`);
-    console.log(`  - Images: ${result.images.length}`);
-    console.log(`  - Videos: ${result.videos.length}`);
-    console.log(
-      `  - Total: ${result.links.length + result.images.length + result.videos.length}`
-    );
-    console.log(`Output saved to: ${outputPath}`);
-    console.log('-'.repeat(60));
-
-    // Print sample of the transformation
-    const sampleLines = result.markdown.split('\n').slice(0, 10).join('\n');
-    console.log('\nSample of transformed content:');
-    console.log('-'.repeat(30));
-    console.log(sampleLines);
-    console.log('-'.repeat(30));
-    console.log('... (continued in output file)');
-  } catch (error) {
-    console.error('Error processing Wikipedia article:', error);
-    process.exit(1);
-  }
-}
-
-/**
- * Generate a comprehensive reference appendix with all media links
- */
-function generateReferenceAppendix(result: {
-  links: Array<{ originalUrl: string; title?: string; text?: string }>;
-  images: Array<{ originalUrl: string; title?: string }>;
-  videos: Array<{ originalUrl: string; title?: string }>;
-}): string {
-  let appendix = '\n\n' + '---'.repeat(10) + '\n\n';
-  appendix += '# References\n\n';
-
-  if (result.links.length > 0) {
-    appendix += '## Links\n\n';
-    result.links.forEach((link, index) => {
-      // Clean and format text for display
-      let displayText = '';
-      if (link.text != null && link.text.trim()) {
-        // Limit length for very long link text
-        let cleanText = link.text.trim();
-        if (cleanText.length > 50) {
-          cleanText = cleanText.substring(0, 47) + '...';
-        }
-        displayText = ` - "${cleanText}"`;
-      }
-
-      appendix += `**link#${index + 1}**: ${link.originalUrl}${displayText}\n\n`;
-    });
-  }
-
-  if (result.images.length > 0) {
-    appendix += '## Images\n\n';
-    result.images.forEach((image, index) => {
-      const displayTitle =
-        image.title != null && image.title.trim()
-          ? ` - ${image.title.trim()}`
-          : '';
-      appendix += `**image#${index + 1}**: ${image.originalUrl}${displayTitle}\n\n`;
-    });
-  }
-
-  if (result.videos.length > 0) {
-    appendix += '## Videos\n\n';
-    result.videos.forEach((video, index) => {
-      const displayTitle =
-        video.title != null && video.title.trim()
-          ? ` - ${video.title.trim()}`
-          : '';
-      appendix += `**video#${index + 1}**: ${video.originalUrl}${displayTitle}\n\n`;
-    });
-  }
-
-  // Add a category breakdown to show what types of links were found
-  const totalRefs =
-    result.links.length + result.images.length + result.videos.length;
-
-  appendix += '## Summary\n\n';
-  appendix += `Total references: **${totalRefs}**\n\n`;
-  appendix += `- Links: ${result.links.length}\n`;
-  appendix += `- Images: ${result.images.length}\n`;
-  appendix += `- Videos: ${result.videos.length}\n`;
-
-  return appendix;
-}
-
-// Using async IIFE to allow for better error handling
-(async (): Promise<void> => {
-  try {
-    await processWikipediaArticle();
-  } catch (error) {
-    console.error('Unhandled error:', error);
-    process.exit(1);
-  }
-})();

package/src/utils/__tests__/childAgentContext.test.ts

@@ -1,217 +0,0 @@
-/**
- * Unit tests for child-agent context preparation.
- *
- * These strategies are the primary defense against schema confusion and
- * Bedrock/VertexAI message-shape rejections, so their behavior must be
- * locked down with fixtures that mirror real provider output shapes.
- */
-import {
-  AIMessage,
-  HumanMessage,
-  SystemMessage,
-  ToolMessage,
-} from '@langchain/core/messages';
-import type { BaseMessage } from '@langchain/core/messages';
-import {
-  HANDOFF_TAIL_CONTEXT_PREFIX,
-  buildIsolatedChildPrompt,
-  prepareHandoffMessages,
-  prepareIsolatedChildMessages,
-} from '../childAgentContext';
-
-describe('buildIsolatedChildPrompt', () => {
-  it('wraps upstream text in the prior-step / your-task sections', () => {
-    const out = buildIsolatedChildPrompt('RESEARCH FINDINGS');
-    expect(out).toContain('## Prior step output');
-    expect(out).toContain('RESEARCH FINDINGS');
-    expect(out).toContain('## Your task');
-    expect(out).toMatch(/You MUST now/);
-  });
-
-  it('instructs the model to call tools directly without asking for clarification', () => {
-    const out = buildIsolatedChildPrompt('x');
-    expect(out).toMatch(/call it directly/);
-    expect(out).toMatch(/do not ask for clarification/);
-  });
-});
-
-describe('prepareHandoffMessages', () => {
-  it('returns an empty array unchanged', () => {
-    expect(prepareHandoffMessages([])).toEqual([]);
-  });
-
-  it('preserves system and human messages verbatim', () => {
-    const msgs: BaseMessage[] = [
-      new SystemMessage('sys'),
-      new HumanMessage('hello'),
-    ];
-    const out = prepareHandoffMessages(msgs);
-    expect(out).toHaveLength(2);
-    expect(out[0].getType()).toBe('system');
-    expect(out[1].getType()).toBe('human');
-  });
-
-  it('drops orphaned tool_use blocks (handoff tool has no matching result)', () => {
-    const ai = new AIMessage({
-      content: 'transferring',
-      tool_calls: [{ name: 'handoff_to_writer', args: {}, id: 'call_1' }],
-    });
-    const out = prepareHandoffMessages([new HumanMessage('go'), ai]);
-    // The assistant tail becomes a HumanMessage with the context prefix
-    // because the orphaned tool_use was stripped, leaving only text.
-    expect(out).toHaveLength(2);
-    expect(out[1].getType()).toBe('human');
-    expect(out[1].content).toContain('transferring');
-    expect(out[1].content).toContain(HANDOFF_TAIL_CONTEXT_PREFIX);
-  });
-
-  it('compacts paired tool_use/tool_result into a text summary', () => {
-    const ai = new AIMessage({
-      content: '',
-      tool_calls: [{ name: 'search', args: { q: 'x' }, id: 'call_a' }],
-    });
-    const toolResult = new ToolMessage({
-      content: 'hit: 42',
-      tool_call_id: 'call_a',
-    });
-    const out = prepareHandoffMessages([
-      new HumanMessage('find x'),
-      ai,
-      toolResult,
-      new HumanMessage('what did you find?'),
-    ]);
-    // The paired tool_use+result should have become a text summary on the
-    // rewritten AI message; the original ToolMessage should be gone.
-    expect(out.some((m) => m.getType() === 'tool')).toBe(false);
-    const rewrittenAI = out.find((m) => m.getType() === 'ai');
-    expect(rewrittenAI).toBeDefined();
-    expect(String(rewrittenAI?.content)).toContain('[Tool "search"');
-    expect(String(rewrittenAI?.content)).toContain('hit: 42');
-  });
-
-  it('truncates long tool_result content at 500 chars in the summary', () => {
-    const long = 'x'.repeat(1200);
-    const ai = new AIMessage({
-      content: '',
-      tool_calls: [{ name: 'dump', args: {}, id: 'call_big' }],
-    });
-    const tool = new ToolMessage({ content: long, tool_call_id: 'call_big' });
-    const out = prepareHandoffMessages([new HumanMessage('hi'), ai, tool]);
-    // After the paired compaction the tail is an AIMessage with no text, so
-    // it gets dropped (empty) — find the one that carries the summary by
-    // scanning for the "[Tool" marker in any message.
-    const blob = out.map((m) => String(m.content)).join(' ');
-    expect(blob).toContain('[Tool "dump"');
-    // The truncated slice is 500 chars of x, not the full 1200.
-    const match = blob.match(/x+/);
-    expect(match).toBeTruthy();
-    expect((match?.[0].length ?? 0) <= 500).toBe(true);
-  });
-
-  it('ensures the tail message is a HumanMessage by rewriting a trailing AI', () => {
-    const msgs: BaseMessage[] = [
-      new HumanMessage('question'),
-      new AIMessage('plain text answer'),
-    ];
-    const out = prepareHandoffMessages(msgs);
-    expect(out[out.length - 1].getType()).toBe('human');
-    expect(out[out.length - 1].content).toBe(
-      `${HANDOFF_TAIL_CONTEXT_PREFIX}plain text answer`
-    );
-  });
-
-  it('drops a trailing empty AIMessage instead of creating an empty human', () => {
-    const msgs: BaseMessage[] = [
-      new HumanMessage('q'),
-      new AIMessage(''), // empty, nothing to carry forward
-    ];
-    const out = prepareHandoffMessages(msgs);
-    expect(out).toHaveLength(1);
-    expect(out[0].getType()).toBe('human');
-  });
-});
-
-describe('prepareIsolatedChildMessages', () => {
-  it('returns empty input unchanged', () => {
-    expect(prepareIsolatedChildMessages([])).toEqual([]);
-  });
-
-  it('keeps only the first human message and a synthetic directive', () => {
-    const msgs: BaseMessage[] = [
-      new HumanMessage('original request'),
-      new AIMessage('upstream produced this result'),
-    ];
-    const out = prepareIsolatedChildMessages(msgs);
-    expect(out).toHaveLength(2);
-    expect(out[0].getType()).toBe('human');
-    expect(out[0].content).toBe('original request');
-    expect(out[1].getType()).toBe('human');
-    expect(String(out[1].content)).toContain('upstream produced this result');
-    expect(String(out[1].content)).toContain('## Your task');
-  });
-
-  it('discards upstream tool_use/tool_result blocks entirely', () => {
-    const aiWithTool = new AIMessage({
-      content: 'working',
-      tool_calls: [{ name: 'search', args: {}, id: 'c1' }],
-    });
-    const toolResult = new ToolMessage({
-      content: 'search result',
-      tool_call_id: 'c1',
-    });
-    const aiFinal = new AIMessage('final summary text');
-    const out = prepareIsolatedChildMessages([
-      new HumanMessage('user ask'),
-      aiWithTool,
-      toolResult,
-      aiFinal,
-    ]);
-    // Must not contain any ToolMessage or upstream tool_calls.
-    expect(out.some((m) => m.getType() === 'tool')).toBe(false);
-    // The synthetic directive should reference only the final text output.
-    const directive = String(out[1].content);
-    expect(directive).toContain('final summary text');
-    expect(directive).not.toContain('search result');
-  });
-
-  it('picks the most recent non-empty AI text output', () => {
-    const msgs: BaseMessage[] = [
-      new HumanMessage('req'),
-      new AIMessage('older text'),
-      new AIMessage(''),
-      new AIMessage('newer text'),
-    ];
-    const out = prepareIsolatedChildMessages(msgs);
-    expect(String(out[1].content)).toContain('newer text');
-    expect(String(out[1].content)).not.toContain('older text');
-  });
-
-  it('handles AI content in Anthropic array-of-blocks shape', () => {
-    const ai = new AIMessage({
-      content: [
-        { type: 'tool_use', name: 'x', input: {}, id: 'c1' },
-        { type: 'text', text: 'block text result' },
-      ] as unknown as string, // the SDK types are strict, cast for fixture
-    });
-    const out = prepareIsolatedChildMessages([new HumanMessage('q'), ai]);
-    expect(out).toHaveLength(2);
-    expect(String(out[1].content)).toContain('block text result');
-  });
-
-  it('falls back to raw messages if no human and no upstream text exist', () => {
-    const msgs: BaseMessage[] = [new SystemMessage('just system')];
-    const out = prepareIsolatedChildMessages(msgs);
-    expect(out).toBe(msgs);
-  });
-
-  it('returns just the user message when upstream has no text content', () => {
-    const msgs: BaseMessage[] = [
-      new HumanMessage('only user'),
-      new AIMessage(''),
-    ];
-    const out = prepareIsolatedChildMessages(msgs);
-    expect(out).toHaveLength(1);
-    expect(out[0].getType()).toBe('human');
-    expect(out[0].content).toBe('only user');
-  });
-});

package/src/utils/__tests__/credentials.test.ts

@@ -1,130 +0,0 @@
-import {
-  mergeCredentials,
-  collectRequiredAuthFields,
-  filterForwardableCredentials,
-  findMissingCredentials,
-  credentialsFromEnv,
-  isForwardable,
-  CredentialOrigin,
-} from '../credentials';
-import { AuthSource, CapabilityKind, type Capability } from '@/providers/types';
-
-const makeCap = (
-  name: string,
-  authFields: Array<[string, AuthSource?, boolean?]>
-): Capability => ({
-  kind: CapabilityKind.TOOL,
-  name,
-  description: `${name} capability`,
-  authConfig: authFields.map(([authField, source, required]) => ({
-    authField,
-    source,
-    required,
-  })),
-  metadata: {},
-});
-
-describe('mergeCredentials', () => {
-  it('first layer wins on collision', () => {
-    const result = mergeCredentials(
-      { origin: CredentialOrigin.RUNTIME, values: { KEY: 'runtime' } },
-      {
-        origin: CredentialOrigin.AGENT,
-        values: { KEY: 'agent', OTHER: 'agent' },
-      },
-      { origin: CredentialOrigin.ENV, values: { KEY: 'env', THIRD: 'env' } }
-    );
-    expect(result.KEY).toBe('runtime');
-    expect(result.OTHER).toBe('agent');
-    expect(result.THIRD).toBe('env');
-  });
-
-  it('skips empty/undefined/null values', () => {
-    const result = mergeCredentials(
-      { origin: CredentialOrigin.RUNTIME, values: { KEY: '' } },
-      { origin: CredentialOrigin.ENV, values: { KEY: 'fallback' } }
-    );
-    expect(result.KEY).toBe('fallback');
-  });
-
-  it('returns empty map when all layers empty', () => {
-    const result = mergeCredentials();
-    expect(result).toEqual({});
-  });
-});
-
-describe('collectRequiredAuthFields', () => {
-  it('unions auth fields across capabilities', () => {
-    const caps = [
-      makeCap('a', [['KEY_1'], ['KEY_2']]),
-      makeCap('b', [['KEY_2'], ['KEY_3']]),
-    ];
-    const fields = collectRequiredAuthFields(caps);
-    expect(fields.sort()).toEqual(['KEY_1', 'KEY_2', 'KEY_3']);
-  });
-});
-
-describe('filterForwardableCredentials', () => {
-  it('strips credentials whose source is SERVER', () => {
-    const caps = [
-      makeCap('x', [
-        ['SERVER_KEY', AuthSource.SERVER],
-        ['USER_KEY', AuthSource.USER],
-      ]),
-    ];
-    const filtered = filterForwardableCredentials(
-      { SERVER_KEY: 'secret', USER_KEY: 'u1', UNRELATED: 'ok' },
-      caps
-    );
-    expect(filtered).toEqual({ USER_KEY: 'u1', UNRELATED: 'ok' });
-  });
-});
-
-describe('findMissingCredentials', () => {
-  it('flags missing required fields that are not server-resolved', () => {
-    const cap = makeCap('tool', [
-      ['REQUIRED_USER', AuthSource.USER, true],
-      ['OPTIONAL_USER', AuthSource.USER, false],
-      ['SERVER_MANAGED', AuthSource.SERVER, true],
-    ]);
-    const missing = findMissingCredentials(cap, {});
-    expect(missing).toEqual(['REQUIRED_USER']);
-  });
-
-  it('returns empty when all required are present', () => {
-    const cap = makeCap('tool', [['KEY', AuthSource.USER, true]]);
-    expect(findMissingCredentials(cap, { KEY: 'val' })).toEqual([]);
-  });
-});
-
-describe('credentialsFromEnv', () => {
-  it('reads only fields present in env', () => {
-    const layer = credentialsFromEnv(['A', 'B', 'C'], {
-      A: '1',
-      C: '3',
-    } as NodeJS.ProcessEnv);
-    expect(layer.values).toEqual({ A: '1', C: '3' });
-    expect(layer.origin).toBe(CredentialOrigin.ENV);
-  });
-});
-
-describe('isForwardable', () => {
-  it('SERVER is not forwardable', () => {
-    expect(isForwardable({ authField: 'K', source: AuthSource.SERVER })).toBe(
-      false
-    );
-  });
-  it('USER is forwardable', () => {
-    expect(isForwardable({ authField: 'K', source: AuthSource.USER })).toBe(
-      true
-    );
-  });
-  it('FORWARDED is forwardable', () => {
-    expect(
-      isForwardable({ authField: 'K', source: AuthSource.FORWARDED })
-    ).toBe(true);
-  });
-  it('defaults to forwardable when source is undefined', () => {
-    expect(isForwardable({ authField: 'K' })).toBe(true);
-  });
-});

package/src/utils/__tests__/httpClient.test.ts

@@ -1,75 +0,0 @@
-import { createHttpClient, HttpError, assertOk } from '../httpClient';
-
-describe('createHttpClient', () => {
-  it('creates an axios instance with baseURL', () => {
-    const client = createHttpClient({
-      baseURL: 'http://localhost:3500',
-      apiKey: 'k',
-    });
-    expect(client.defaults.baseURL).toBe('http://localhost:3500');
-  });
-
-  it('sets x-api-key header when apiKey provided', () => {
-    const client = createHttpClient({ baseURL: 'http://x', apiKey: 'my-key' });
-    expect(client.defaults.headers['x-api-key']).toBe('my-key');
-  });
-
-  it('omits x-api-key when apiKey not provided', () => {
-    const client = createHttpClient({ baseURL: 'http://x' });
-    expect(client.defaults.headers['x-api-key']).toBeUndefined();
-  });
-
-  it('merges custom headers', () => {
-    const client = createHttpClient({
-      baseURL: 'http://x',
-      apiKey: 'k',
-      headers: { 'x-custom': 'v' },
-    });
-    expect(client.defaults.headers['x-custom']).toBe('v');
-  });
-
-  it('applies timeout', () => {
-    const client = createHttpClient({ baseURL: 'http://x', timeoutMs: 5000 });
-    expect(client.defaults.timeout).toBe(5000);
-  });
-
-  it('default timeout is 30_000ms', () => {
-    const client = createHttpClient({ baseURL: 'http://x' });
-    expect(client.defaults.timeout).toBe(30_000);
-  });
-
-  it('proxy=null disables proxy even if env is set', () => {
-    const prev = process.env.PROXY;
-    process.env.PROXY = 'http://should-be-ignored';
-    try {
-      const client = createHttpClient({ baseURL: 'http://x', proxy: null });
-      expect(client.defaults.httpsAgent).toBeUndefined();
-    } finally {
-      process.env.PROXY = prev;
-    }
-  });
-});
-
-describe('HttpError', () => {
-  it('captures status, url, and body', () => {
-    const err = new HttpError(404, '/foo', { message: 'not found' });
-    expect(err.status).toBe(404);
-    expect(err.url).toBe('/foo');
-    expect(err.body).toEqual({ message: 'not found' });
-    expect(err.name).toBe('HttpError');
-    expect(err.message).toContain('404');
-  });
-});
-
-describe('assertOk', () => {
-  it('passes for 2xx', () => {
-    expect(() => assertOk(200, '/x', {})).not.toThrow();
-    expect(() => assertOk(204, '/x', {})).not.toThrow();
-    expect(() => assertOk(299, '/x', {})).not.toThrow();
-  });
-  it('throws for non-2xx', () => {
-    expect(() => assertOk(400, '/x', {})).toThrow(HttpError);
-    expect(() => assertOk(500, '/x', {})).toThrow(HttpError);
-    expect(() => assertOk(199, '/x', {})).toThrow(HttpError);
-  });
-});

package/src/utils/__tests__/toolManifest.test.ts

@@ -1,116 +0,0 @@
-import { ManifestCache, filterToCacheKey, applyFilter } from '../toolManifest';
-import { CapabilityKind, type Capability } from '@/providers/types';
-
-const makeCap = (
-  name: string,
-  tags: string[] = [],
-  kind: CapabilityKind = CapabilityKind.TOOL
-): Capability => ({
-  kind,
-  name,
-  description: `${name} cap`,
-  authConfig: [],
-  metadata: { tags },
-});
-
-describe('ManifestCache', () => {
-  it('stores and retrieves by key', () => {
-    const cache = new ManifestCache({ ttlMs: 10_000 });
-    const caps = [makeCap('a')];
-    cache.set('k', caps);
-    expect(cache.get('k')).toBe(caps);
-    expect(cache.size).toBe(1);
-  });
-
-  it('returns undefined on miss', () => {
-    const cache = new ManifestCache();
-    expect(cache.get('nope')).toBeUndefined();
-  });
-
-  it('expires after ttlMs', async () => {
-    const cache = new ManifestCache({ ttlMs: 1 });
-    cache.set('k', [makeCap('a')]);
-    await new Promise((r) => setTimeout(r, 5));
-    expect(cache.get('k')).toBeUndefined();
-  });
-
-  it('ttlMs=0 disables caching', () => {
-    const cache = new ManifestCache({ ttlMs: 0 });
-    cache.set('k', [makeCap('a')]);
-    expect(cache.get('k')).toBeUndefined();
-  });
-
-  it('clear removes all entries', () => {
-    const cache = new ManifestCache({ ttlMs: 10_000 });
-    cache.set('a', []);
-    cache.set('b', []);
-    cache.clear();
-    expect(cache.size).toBe(0);
-  });
-});
-
-describe('filterToCacheKey', () => {
-  it('returns __all__ for undefined filter', () => {
-    expect(filterToCacheKey()).toBe('__all__');
-    expect(filterToCacheKey({})).toBe('__all__');
-  });
-
-  it('is deterministic regardless of tag order', () => {
-    const k1 = filterToCacheKey({ tags: ['b', 'a'] });
-    const k2 = filterToCacheKey({ tags: ['a', 'b'] });
-    expect(k1).toBe(k2);
-  });
-
-  it('is deterministic regardless of names order', () => {
-    const k1 = filterToCacheKey({ names: ['z', 'a'] });
-    const k2 = filterToCacheKey({ names: ['a', 'z'] });
-    expect(k1).toBe(k2);
-  });
-
-  it('combines kind + tags + names', () => {
-    const k = filterToCacheKey({
-      kind: CapabilityKind.TOOL,
-      tags: ['x'],
-      names: ['y'],
-    });
-    expect(k).toContain('kind=tool');
-    expect(k).toContain('tags=x');
-    expect(k).toContain('names=y');
-  });
-});
-
-describe('applyFilter', () => {
-  const caps = [
-    makeCap('alpha', ['search', 'web'], CapabilityKind.TOOL),
-    makeCap('beta', ['image'], CapabilityKind.TOOL),
-    makeCap('gamma', ['search'], CapabilityKind.SKILL),
-  ];
-
-  it('no filter returns all', () => {
-    expect(applyFilter(caps)).toHaveLength(3);
-    expect(applyFilter(caps, {})).toHaveLength(3);
-  });
-
-  it('kind filter', () => {
-    const out = applyFilter(caps, { kind: CapabilityKind.TOOL });
-    expect(out.map((c) => c.name)).toEqual(['alpha', 'beta']);
-  });
-
-  it('tags filter — any match', () => {
-    const out = applyFilter(caps, { tags: ['search'] });
-    expect(out.map((c) => c.name).sort()).toEqual(['alpha', 'gamma']);
-  });
-
-  it('names filter — inclusion', () => {
-    const out = applyFilter(caps, { names: ['alpha', 'gamma'] });
-    expect(out.map((c) => c.name).sort()).toEqual(['alpha', 'gamma']);
-  });
-
-  it('combined filter — AND semantics', () => {
-    const out = applyFilter(caps, {
-      kind: CapabilityKind.TOOL,
-      tags: ['search'],
-    });
-    expect(out.map((c) => c.name)).toEqual(['alpha']);
-  });
-});