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

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']);
-  });
-});