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

package/src/graphs/handoffValidation.test.ts

@@ -1,353 +0,0 @@
-/**
- * Unit tests for MultiAgentGraph handoff validation and pre-handoff compaction.
- *
- * These tests exercise the handoff logic (destination validation, compaction threshold,
- * briefing generation, error formatting) without instantiating the full MultiAgentGraph.
- * We test the helper functions directly and verify the behavioral patterns that
- * the graph's agent node closure relies on.
- */
-import {
-  HumanMessage,
-  AIMessage,
-  SystemMessage,
-  ToolMessage,
-} from '@langchain/core/messages';
-import {
-  summarize,
-  createEmergencySummary,
-  buildFullSummaryPrompt,
-  formatMessagesForSummary,
-} from '@/messages';
-
-// ---------------------------------------------------------------------------
-// 1. Handoff destination validation logic
-// ---------------------------------------------------------------------------
-describe('handoff destination validation', () => {
-  it('detects non-existent agent in contexts map', () => {
-    const agentContexts = new Map([
-      ['agent-a', { agentId: 'agent-a', name: 'Agent A' }],
-      ['agent-b', { agentId: 'agent-b', name: 'Agent B' }],
-    ]);
-
-    const handoffDest = 'agent-c';
-    expect(agentContexts.has(handoffDest)).toBe(false);
-
-    const availableAgents = Array.from(agentContexts.keys()).join(', ');
-    expect(availableAgents).toBe('agent-a, agent-b');
-  });
-
-  it('passes validation for existing agent', () => {
-    const agentContexts = new Map([
-      ['agent-a', { agentId: 'agent-a', name: 'Agent A' }],
-    ]);
-
-    expect(agentContexts.has('agent-a')).toBe(true);
-  });
-
-  it('handles empty contexts map', () => {
-    const agentContexts = new Map<string, { agentId: string; name: string }>();
-    expect(agentContexts.has('any-agent')).toBe(false);
-
-    const availableAgents = Array.from(agentContexts.keys()).join(', ');
-    expect(availableAgents).toBe('');
-  });
-});
-
-// ---------------------------------------------------------------------------
-// 2. Pre-handoff compaction threshold
-// ---------------------------------------------------------------------------
-describe('pre-handoff compaction threshold', () => {
-  it('triggers compaction when context exceeds 70% of receiver budget', () => {
-    const receiverBudget = 100000;
-    const currentSize = 75000; // 75%
-    expect(currentSize > receiverBudget * 0.7).toBe(true);
-  });
-
-  it('skips compaction when context fits within 70% of receiver budget', () => {
-    const receiverBudget = 100000;
-    const currentSize = 60000; // 60%
-    expect(currentSize > receiverBudget * 0.7).toBe(false);
-  });
-
-  it('triggers compaction at exactly the boundary (>70%)', () => {
-    const receiverBudget = 100000;
-    // Exactly 70% should NOT trigger (condition is strictly >)
-    expect(70000 > receiverBudget * 0.7).toBe(false);
-    // Just above 70% should trigger
-    expect(70001 > receiverBudget * 0.7).toBe(true);
-  });
-
-  it('computes summary budget as 20% of receiver budget', () => {
-    const receiverBudget = 100000;
-    const summaryBudget = Math.floor(receiverBudget * 0.2);
-    expect(summaryBudget).toBe(20000);
-  });
-});
-
-// ---------------------------------------------------------------------------
-// 3. Handoff briefing via summarize (multi-agent aware)
-// ---------------------------------------------------------------------------
-describe('handoff briefing generation', () => {
-  it('generates multi-agent aware briefing', async () => {
-    const messages = [
-      new HumanMessage('Analyze the data'),
-      new AIMessage('I found 3 key patterns...'),
-      new HumanMessage('Can you elaborate on pattern 2?'),
-      new AIMessage('Pattern 2 shows...'),
-    ];
-
-    const callback = jest
-      .fn()
-      .mockResolvedValue(
-        '## 5. Agent Workflow State\n- Agent A analyzed data and found 3 patterns'
-      );
-
-    const result = await summarize(messages, callback, {
-      isMultiAgent: true,
-      agentWorkflowState: {
-        currentAgentId: 'agent-b',
-        agentChain: ['agent-a', 'agent-b'],
-        pendingAgents: [],
-      },
-      summaryBudget: 2000,
-    });
-
-    // Without a tokenCounter the budget check is skipped, so full tier is returned
-    expect(result.tier).toBe('full');
-    expect(result.summary).toContain('Agent Workflow State');
-    // Verify callback was called with the full prompt containing agent workflow info
-    expect(callback).toHaveBeenCalledWith(
-      expect.stringContaining('Agent Workflow State'),
-      expect.any(Number)
-    );
-  });
-
-  it('includes agent chain in the prompt', () => {
-    const conversation = formatMessagesForSummary([new HumanMessage('Hello')]);
-    const prompt = buildFullSummaryPrompt(conversation, {
-      isMultiAgent: true,
-      agentWorkflowState: {
-        currentAgentId: 'agent-b',
-        agentChain: ['agent-a', 'agent-b'],
-        pendingAgents: ['agent-c'],
-      },
-    });
-
-    expect(prompt).toContain('Current agent: agent-b');
-    expect(prompt).toContain('Agent chain: agent-a -> agent-b');
-    expect(prompt).toContain('Pending agents: agent-c');
-  });
-
-  it('shows N/A for single-agent conversations', () => {
-    const conversation = formatMessagesForSummary([new HumanMessage('Hello')]);
-    const prompt = buildFullSummaryPrompt(conversation);
-
-    expect(prompt).toContain('N/A (single-agent conversation)');
-  });
-});
-
-// ---------------------------------------------------------------------------
-// 4. Emergency briefing fallback
-// ---------------------------------------------------------------------------
-describe('emergency briefing fallback', () => {
-  it('generates briefing without LLM when callback fails', async () => {
-    const messages = [
-      new HumanMessage('Analyze this'),
-      new AIMessage('Here is the analysis...'),
-    ];
-
-    const failingCallback = jest
-      .fn()
-      .mockRejectedValue(new Error('LLM timeout'));
-    const result = await summarize(messages, failingCallback);
-
-    expect(result.tier).toBe('emergency');
-    expect(result.summary).toContain('[Emergency Context Summary]');
-    expect(result.summary).toContain('Analyze this');
-  });
-
-  it('falls to emergency when both full and simple callbacks fail', async () => {
-    let callCount = 0;
-    const failingCallback = jest.fn().mockImplementation(() => {
-      callCount++;
-      throw new Error(`Failure #${callCount}`);
-    });
-
-    const messages = [
-      new HumanMessage('Do something'),
-      new AIMessage('Working on it...'),
-      new ToolMessage({
-        content: 'result',
-        tool_call_id: 'tc-1',
-        name: 'search',
-      }),
-    ];
-
-    const result = await summarize(messages, failingCallback);
-
-    expect(result.tier).toBe('emergency');
-    expect(result.summary).toContain('Do something');
-    expect(result.summary).toContain('Working on it...');
-    expect(result.summary).toContain('search');
-    expect(result.messagesCompacted).toBe(3);
-  });
-
-  it('createEmergencySummary captures first user message and last AI message', () => {
-    const messages = [
-      new HumanMessage('First user message'),
-      new AIMessage('First AI response'),
-      new HumanMessage('Second user message'),
-      new AIMessage('Second AI response'),
-    ];
-
-    const summary = createEmergencySummary(messages);
-
-    expect(summary).toContain('[Emergency Context Summary]');
-    expect(summary).toContain('Original request: First user message');
-    expect(summary).toContain('Last response: Second AI response');
-    expect(summary).toContain('Tools used: none');
-    expect(summary).toContain('Messages compacted: 4');
-  });
-
-  it('createEmergencySummary collects unique tool names', () => {
-    const messages = [
-      new HumanMessage('Test'),
-      new ToolMessage({ content: 'ok', tool_call_id: 'tc-1', name: 'search' }),
-      new ToolMessage({ content: 'ok', tool_call_id: 'tc-2', name: 'search' }),
-      new ToolMessage({
-        content: 'ok',
-        tool_call_id: 'tc-3',
-        name: 'calculator',
-      }),
-    ];
-
-    const summary = createEmergencySummary(messages);
-
-    expect(summary).toContain('search');
-    expect(summary).toContain('calculator');
-  });
-});
-
-// ---------------------------------------------------------------------------
-// 5. Handoff error ToolMessage format
-// ---------------------------------------------------------------------------
-describe('handoff error message format', () => {
-  it('creates properly formatted error ToolMessage', () => {
-    const availableAgents = 'agent-a, agent-b, agent-c';
-    const handoffDest = 'nonexistent-agent';
-
-    const errorMsg = new ToolMessage({
-      content: `Transfer failed: agent "${handoffDest}" does not exist. Available agents: ${availableAgents}. Please choose a valid agent to transfer to.`,
-      tool_call_id: 'call-123',
-      name: `transfer_to_${handoffDest}`,
-    });
-
-    expect(errorMsg.content).toContain('does not exist');
-    expect(errorMsg.content).toContain(availableAgents);
-    expect(errorMsg.tool_call_id).toBe('call-123');
-    expect(errorMsg.name).toBe('transfer_to_nonexistent-agent');
-  });
-
-  it('error message includes all available agents', () => {
-    const agentContexts = new Map([
-      ['alpha', {}],
-      ['beta', {}],
-      ['gamma', {}],
-    ]);
-    const availableAgents = Array.from(agentContexts.keys()).join(', ');
-
-    const errorMsg = new ToolMessage({
-      content: `Transfer failed: agent "delta" does not exist. Available agents: ${availableAgents}. Please choose a valid agent to transfer to.`,
-      tool_call_id: 'call-456',
-      name: 'lc_transfer_to_delta',
-    });
-
-    expect(errorMsg.content).toContain('alpha, beta, gamma');
-    expect(errorMsg.getType()).toBe('tool');
-  });
-});
-
-// ---------------------------------------------------------------------------
-// 6. Compacted handoff message structure
-// ---------------------------------------------------------------------------
-describe('compacted handoff message structure', () => {
-  it('keeps briefing + last 3 messages', () => {
-    const originalMessages = [
-      new HumanMessage('msg 1'),
-      new AIMessage('msg 2'),
-      new HumanMessage('msg 3'),
-      new AIMessage('msg 4'),
-      new HumanMessage('msg 5'),
-      new AIMessage('msg 6'),
-    ];
-
-    const briefingMsg = new SystemMessage(
-      '[Handoff Briefing]\nAgent A completed analysis'
-    );
-    const keepCount = Math.min(3, originalMessages.length);
-    const compacted = [
-      briefingMsg,
-      ...originalMessages.slice(originalMessages.length - keepCount),
-    ];
-
-    expect(compacted).toHaveLength(4); // briefing + 3 messages
-    expect(compacted[0].getType()).toBe('system');
-    expect(compacted[0].content).toContain('Handoff Briefing');
-    expect(compacted[3].getType()).toBe('ai'); // last message preserved
-  });
-
-  it('keeps all messages when fewer than 3 remain', () => {
-    const originalMessages = [
-      new HumanMessage('only message'),
-      new AIMessage('only response'),
-    ];
-
-    const briefingMsg = new SystemMessage('[Handoff Briefing]\nBriefing text');
-    const keepCount = Math.min(3, originalMessages.length);
-    const compacted = [
-      briefingMsg,
-      ...originalMessages.slice(originalMessages.length - keepCount),
-    ];
-
-    // briefing + 2 original messages
-    expect(compacted).toHaveLength(3);
-    expect(compacted[1].content).toBe('only message');
-    expect(compacted[2].content).toBe('only response');
-  });
-
-  it('preserves the handoff tool message as the last message', () => {
-    const originalMessages = [
-      new HumanMessage('do X'),
-      new AIMessage('calling agent-b'),
-      new ToolMessage({
-        content: 'Transferred to agent-b',
-        tool_call_id: 'tc-handoff',
-        name: 'lc_transfer_to_agent-b',
-      }),
-    ];
-
-    const briefingMsg = new SystemMessage('[Handoff Briefing]\nContext');
-    const keepCount = Math.min(3, originalMessages.length);
-    const compacted = [
-      briefingMsg,
-      ...originalMessages.slice(originalMessages.length - keepCount),
-    ];
-
-    const lastMsg = compacted[compacted.length - 1];
-    expect(lastMsg.getType()).toBe('tool');
-    expect((lastMsg as ToolMessage).name).toContain('lc_transfer_to_');
-  });
-
-  it('briefing contains sender name in the expected format', () => {
-    const senderName = 'Research Agent';
-    const summaryText = 'User asked about market trends. Found 5 data points.';
-    const briefingMsg = new SystemMessage(
-      `[Handoff Briefing from "${senderName}"]\n${summaryText}`
-    );
-
-    expect(briefingMsg.content).toContain(
-      'Handoff Briefing from "Research Agent"'
-    );
-    expect(briefingMsg.content).toContain(summaryText);
-  });
-});

package/src/providers/__tests__/ToolsServerCapabilityProvider.integration.spec.ts

@@ -1,79 +0,0 @@
-/**
- * Integration test — exercises ToolsServerCapabilityProvider against a live
- * tools-server instance.
- *
- * RUN REQUIREMENTS:
- *   1. tools-server must be running locally at TOOLS_SERVER_URL
- *   2. TOOLS_SERVER_API_KEY must match the server's configured key
- *
- * The suite is skipped when TOOLS_SERVER_URL is not set so unit CI passes.
- * To run: TOOLS_SERVER_URL=http://localhost:3500 TOOLS_SERVER_API_KEY=test \
- *         npx jest --testPathPatterns=integration
- */
-
-import { ToolsServerCapabilityProvider } from '../tools-server/ToolsServerCapabilityProvider';
-import { CapabilityKind } from '../types';
-
-const baseUrl = process.env.TOOLS_SERVER_URL;
-const apiKey = process.env.TOOLS_SERVER_API_KEY;
-
-const describeIfLive = baseUrl && apiKey ? describe : describe.skip;
-
-describeIfLive('ToolsServerCapabilityProvider (live integration)', () => {
-  let provider: ToolsServerCapabilityProvider;
-
-  beforeAll(() => {
-    provider = new ToolsServerCapabilityProvider({
-      baseUrl: baseUrl as string,
-      apiKey: apiKey as string,
-      manifestTtlMs: 0, // always fresh for tests
-    });
-  });
-
-  it('fetches manifest from live server', async () => {
-    const caps = await provider.fetchManifest();
-    expect(caps.length).toBeGreaterThan(0);
-    for (const cap of caps) {
-      expect(cap.kind).toBe(CapabilityKind.TOOL);
-      expect(typeof cap.name).toBe('string');
-      expect(typeof cap.description).toBe('string');
-      expect(Array.isArray(cap.authConfig)).toBe(true);
-    }
-  });
-
-  it('live manifest contains wikipedia', async () => {
-    const caps = await provider.fetchManifest();
-    const wikipedia = caps.find((c) => c.name === 'wikipedia');
-    expect(wikipedia).toBeDefined();
-    expect(wikipedia?.schema).toBeDefined();
-  });
-
-  it('builds runnables that invoke wikipedia end-to-end', async () => {
-    const caps = await provider.fetchManifest({ names: ['wikipedia'] });
-    expect(caps).toHaveLength(1);
-
-    const [tool] = await provider.createRunnables(caps, {});
-    const result = await tool.invoke({ action: 'search', query: 'TypeScript' });
-
-    // Wikipedia returns JSON-serialized results; just check it's non-empty
-    expect(typeof result).toBe('string');
-    expect((result as string).length).toBeGreaterThan(0);
-  });
-
-  it('surfaces backend failure as thrown error', async () => {
-    // Invoke wikipedia with missing required field → backend returns success:false
-    const caps = await provider.fetchManifest({ names: ['wikipedia'] });
-    const [tool] = await provider.createRunnables(caps, {});
-    await expect(tool.invoke({})).rejects.toThrow();
-  });
-
-  it('filters manifest by names correctly', async () => {
-    const caps = await provider.fetchManifest({
-      names: ['wikipedia', 'arxiv_search'],
-    });
-    expect(caps.length).toBeLessThanOrEqual(2);
-    for (const cap of caps) {
-      expect(['wikipedia', 'arxiv_search']).toContain(cap.name);
-    }
-  });
-});

package/src/providers/__tests__/ToolsServerCapabilityProvider.test.ts

@@ -1,271 +0,0 @@
-import axios from 'axios';
-import { ToolsServerCapabilityProvider } from '../tools-server/ToolsServerCapabilityProvider';
-import { CapabilityKind } from '../types';
-
-/**
- * Tests use a stub axios instance passed via config — no real HTTP.
- */
-function makeStubClient(response: {
-  status: number;
-  data: unknown;
-}): ReturnType<typeof axios.create> {
-  const stub = {
-    get: jest.fn().mockResolvedValue(response),
-    post: jest.fn().mockResolvedValue(response),
-    defaults: { baseURL: 'http://stub', headers: {} },
-  };
-  return stub as unknown as ReturnType<typeof axios.create>;
-}
-
-const manifestFixture = [
-  {
-    pluginKey: 'wikipedia',
-    name: 'Wikipedia',
-    description: 'Search Wikipedia',
-    icon: '/assets/icons/wikipedia.svg',
-    authConfig: [],
-    schema: { type: 'object', properties: { query: { type: 'string' } } },
-    tags: ['search', 'knowledge'],
-  },
-  {
-    pluginKey: 'dalle',
-    name: 'DALL-E 3',
-    description: 'Generate images',
-    authConfig: [
-      {
-        authField: 'OPENAI_API_KEY',
-        label: 'OpenAI API Key',
-        source: 'user',
-        required: true,
-      },
-    ],
-    jsonSchema: { type: 'object', properties: { prompt: { type: 'string' } } },
-    tags: ['image'],
-  },
-];
-
-describe('ToolsServerCapabilityProvider construction', () => {
-  it('throws when baseUrl missing', () => {
-    expect(
-      () => new ToolsServerCapabilityProvider({ baseUrl: '', apiKey: 'k' })
-    ).toThrow(/baseUrl is required/);
-  });
-  it('throws when apiKey missing', () => {
-    expect(
-      () =>
-        new ToolsServerCapabilityProvider({ baseUrl: 'http://x', apiKey: '' })
-    ).toThrow(/apiKey is required/);
-  });
-  it('composes providerId from baseUrl', () => {
-    const p = new ToolsServerCapabilityProvider({
-      baseUrl: 'http://localhost:3500',
-      apiKey: 'k',
-      client: makeStubClient({ status: 200, data: [] }),
-    });
-    expect(p.providerId).toBe('tools-server:http://localhost:3500');
-  });
-});
-
-describe('ToolsServerCapabilityProvider.fetchManifest', () => {
-  it('normalizes manifest entries into Capability shape', async () => {
-    const client = makeStubClient({ status: 200, data: manifestFixture });
-    const p = new ToolsServerCapabilityProvider({
-      baseUrl: 'http://x',
-      apiKey: 'k',
-      client,
-    });
-    const caps = await p.fetchManifest();
-    expect(caps).toHaveLength(2);
-    expect(caps[0].kind).toBe(CapabilityKind.TOOL);
-    expect(caps[0].name).toBe('wikipedia');
-    expect(caps[0].metadata.tags).toEqual(['search', 'knowledge']);
-    expect(caps[1].authConfig[0].authField).toBe('OPENAI_API_KEY');
-    expect(caps[1].authConfig[0].required).toBe(true);
-  });
-
-  it('caches manifest between calls', async () => {
-    const client = makeStubClient({ status: 200, data: manifestFixture });
-    const p = new ToolsServerCapabilityProvider({
-      baseUrl: 'http://x',
-      apiKey: 'k',
-      client,
-    });
-    await p.fetchManifest();
-    await p.fetchManifest();
-    expect((client.get as jest.Mock).mock.calls).toHaveLength(1);
-  });
-
-  it('invalidateCache forces refetch', async () => {
-    const client = makeStubClient({ status: 200, data: manifestFixture });
-    const p = new ToolsServerCapabilityProvider({
-      baseUrl: 'http://x',
-      apiKey: 'k',
-      client,
-    });
-    await p.fetchManifest();
-    p.invalidateCache();
-    await p.fetchManifest();
-    expect((client.get as jest.Mock).mock.calls).toHaveLength(2);
-  });
-
-  it('filters by name', async () => {
-    const client = makeStubClient({ status: 200, data: manifestFixture });
-    const p = new ToolsServerCapabilityProvider({
-      baseUrl: 'http://x',
-      apiKey: 'k',
-      client,
-    });
-    const caps = await p.fetchManifest({ names: ['wikipedia'] });
-    expect(caps).toHaveLength(1);
-    expect(caps[0].name).toBe('wikipedia');
-  });
-
-  it('throws HttpError on non-2xx', async () => {
-    const client = makeStubClient({ status: 500, data: { error: 'boom' } });
-    const p = new ToolsServerCapabilityProvider({
-      baseUrl: 'http://x',
-      apiKey: 'k',
-      client,
-    });
-    await expect(p.fetchManifest()).rejects.toThrow(/HTTP 500/);
-  });
-});
-
-describe('ToolsServerCapabilityProvider.createRunnables', () => {
-  it('returns one StructuredTool per capability', async () => {
-    const client = makeStubClient({ status: 200, data: manifestFixture });
-    const p = new ToolsServerCapabilityProvider({
-      baseUrl: 'http://x',
-      apiKey: 'k',
-      client,
-    });
-    const caps = await p.fetchManifest();
-    const tools = await p.createRunnables(caps, {});
-    expect(tools).toHaveLength(2);
-    expect(tools[0].name).toBe('wikipedia');
-    expect(tools[1].name).toBe('dalle');
-  });
-
-  it('proxy tool invocation POSTs to /execute/:name with credentials', async () => {
-    const client = {
-      get: jest.fn().mockResolvedValue({ status: 200, data: manifestFixture }),
-      post: jest.fn().mockResolvedValue({
-        status: 200,
-        data: {
-          success: true,
-          result: 'Node.js is a JS runtime',
-          timing: { durationMs: 42 },
-        },
-      }),
-      defaults: { baseURL: 'http://stub', headers: {} },
-    };
-    const p = new ToolsServerCapabilityProvider({
-      baseUrl: 'http://x',
-      apiKey: 'k',
-      client: client as unknown as ReturnType<typeof axios.create>,
-    });
-    const caps = await p.fetchManifest();
-    const [wikipedia] = await p.createRunnables(
-      caps.filter((c) => c.name === 'wikipedia'),
-      { WIKIPEDIA_API_KEY: 'test' }
-    );
-    const result = await wikipedia.invoke({ query: 'Node.js' });
-    expect(result).toBe('Node.js is a JS runtime');
-    expect((client.post as jest.Mock).mock.calls[0][0]).toBe(
-      '/execute/wikipedia'
-    );
-    expect((client.post as jest.Mock).mock.calls[0][1]).toEqual({
-      input: { query: 'Node.js' },
-      credentials: { WIKIPEDIA_API_KEY: 'test' },
-    });
-  });
-
-  it('proxy tool surfaces backend success:false as thrown error', async () => {
-    const client = {
-      get: jest.fn().mockResolvedValue({ status: 200, data: manifestFixture }),
-      post: jest.fn().mockResolvedValue({
-        status: 200,
-        data: { success: false, error: 'missing API key' },
-      }),
-      defaults: { baseURL: 'http://stub', headers: {} },
-    };
-    const p = new ToolsServerCapabilityProvider({
-      baseUrl: 'http://x',
-      apiKey: 'k',
-      client: client as unknown as ReturnType<typeof axios.create>,
-    });
-    const caps = await p.fetchManifest();
-    const [dalle] = await p.createRunnables(
-      caps.filter((c) => c.name === 'dalle'),
-      {}
-    );
-    await expect(dalle.invoke({ prompt: 'cat' })).rejects.toThrow(
-      /missing API key/
-    );
-  });
-
-  it('getExecuteAuthHeaders is invoked per call and forwarded as HTTP headers', async () => {
-    const client = {
-      get: jest.fn().mockResolvedValue({ status: 200, data: manifestFixture }),
-      post: jest.fn().mockResolvedValue({
-        status: 200,
-        data: {
-          success: true,
-          result: 'ok',
-          timing: { durationMs: 1 },
-        },
-      }),
-      defaults: { baseURL: 'http://stub', headers: {} },
-    };
-
-    let mintCount = 0;
-    const p = new ToolsServerCapabilityProvider({
-      baseUrl: 'http://x',
-      apiKey: 'k',
-      client: client as unknown as ReturnType<typeof axios.create>,
-      getExecuteAuthHeaders: async () => {
-        mintCount += 1;
-        return { Authorization: `Bearer TOKEN-${mintCount}` };
-      },
-    });
-    const caps = await p.fetchManifest();
-    const [wikipedia] = await p.createRunnables(
-      caps.filter((c) => c.name === 'wikipedia'),
-      {}
-    );
-
-    await wikipedia.invoke({ query: 'a' });
-    await wikipedia.invoke({ query: 'b' });
-
-    // Two invocations → two mints (fresh token each call)
-    expect(mintCount).toBe(2);
-
-    // Each POST includes the Authorization header from the mint
-    const firstCall = (client.post as jest.Mock).mock.calls[0];
-    const secondCall = (client.post as jest.Mock).mock.calls[1];
-    expect(firstCall[2]?.headers).toEqual({ Authorization: 'Bearer TOKEN-1' });
-    expect(secondCall[2]?.headers).toEqual({ Authorization: 'Bearer TOKEN-2' });
-  });
-
-  it('getExecuteAuthHeaders is NOT called during manifest fetch (service-to-service)', async () => {
-    const client = {
-      get: jest.fn().mockResolvedValue({ status: 200, data: manifestFixture }),
-      post: jest.fn(),
-      defaults: { baseURL: 'http://stub', headers: {} },
-    };
-
-    const authBuilder = jest
-      .fn()
-      .mockReturnValue({ Authorization: 'Bearer X' });
-    const p = new ToolsServerCapabilityProvider({
-      baseUrl: 'http://x',
-      apiKey: 'k',
-      client: client as unknown as ReturnType<typeof axios.create>,
-      getExecuteAuthHeaders: authBuilder,
-    });
-
-    await p.fetchManifest();
-    // Manifest fetch is service-to-service — no per-user auth headers
-    expect(authBuilder).not.toHaveBeenCalled();
-  });
-});