@wix/mcp 1.0.75 → 1.0.76

package/build/dts/toolkit.test.js

@@ -1,691 +0,0 @@
-import { describe, test, expect, vi, beforeEach } from 'vitest';
-import { createWixToolkit, extractText, formatToolResultAdditionalFields } from './toolkit.js';
-vi.mock('./docs/get-to-know.js', async (importOriginal) => {
-    const original = await importOriginal();
-    return {
-        ...original,
-        getDynamicContext: vi.fn().mockResolvedValue('')
-    };
-});
-vi.mock('@wix/dynamic-context-enricher', async (importOriginal) => {
-    const original = await importOriginal();
-    return {
-        ...original,
-        getDynamicContext: vi.fn().mockResolvedValue('')
-    };
-});
-// ---------------------------------------------------------------------------
-// Helpers
-// ---------------------------------------------------------------------------
-/** Minimal auth config for tests */
-const testAuth = {
-    siteToken: async () => ({ Authorization: 'Bearer test-site-token' }),
-    accountToken: async () => ({ Authorization: 'Bearer test-account-token' })
-};
-// ---------------------------------------------------------------------------
-// extractText
-// ---------------------------------------------------------------------------
-describe('extractText()', () => {
-    test('extracts text from a single text block', () => {
-        const result = {
-            content: [{ type: 'text', text: 'hello world' }]
-        };
-        expect(extractText(result)).toBe('hello world');
-    });
-    test('concatenates multiple text blocks with newline', () => {
-        const result = {
-            content: [
-                { type: 'text', text: 'line 1' },
-                { type: 'text', text: 'line 2' }
-            ]
-        };
-        expect(extractText(result)).toBe('line 1\nline 2');
-    });
-    test('filters out non-text content blocks', () => {
-        const result = {
-            content: [
-                { type: 'text', text: 'hello' },
-                { type: 'image', data: 'base64...', mimeType: 'image/png' },
-                { type: 'text', text: 'world' }
-            ]
-        };
-        expect(extractText(result)).toBe('hello\nworld');
-    });
-    test('returns empty string for content with no text blocks', () => {
-        const result = {
-            content: [
-                { type: 'image', data: 'base64...', mimeType: 'image/png' }
-            ]
-        };
-        expect(extractText(result)).toBe('');
-    });
-    test('returns empty string for empty content array', () => {
-        const result = { content: [] };
-        expect(extractText(result)).toBe('');
-    });
-});
-describe('formatToolResultAdditionalFields()', () => {
-    test('serializes a bounded successful result preview', () => {
-        const result = {
-            content: [{ type: 'text', text: 'hello world' }]
-        };
-        expect(JSON.parse(formatToolResultAdditionalFields(result))).toEqual({
-            resultPreview: 'hello world',
-            resultTextLength: 11,
-            resultPreviewTruncated: false,
-            resultContentTypes: ['text']
-        });
-    });
-    test('truncates long text previews', () => {
-        const result = {
-            content: [{ type: 'text', text: 'x'.repeat(4001) }]
-        };
-        const additionalFields = JSON.parse(formatToolResultAdditionalFields(result));
-        expect(additionalFields.resultPreview).toHaveLength(4000);
-        expect(additionalFields.resultTextLength).toBe(4001);
-        expect(additionalFields.resultPreviewTruncated).toBe(true);
-    });
-    test('keeps content type metadata for non-text results', () => {
-        const result = {
-            content: [
-                { type: 'image', data: 'base64...', mimeType: 'image/png' }
-            ]
-        };
-        expect(JSON.parse(formatToolResultAdditionalFields(result))).toEqual({
-            resultPreview: '',
-            resultTextLength: 0,
-            resultPreviewTruncated: false,
-            resultContentTypes: ['image']
-        });
-    });
-});
-// ---------------------------------------------------------------------------
-// createWixToolkit - tool registration
-// ---------------------------------------------------------------------------
-describe('createWixToolkit()', () => {
-    test('registers docs and API tools by default', () => {
-        const toolkit = createWixToolkit({ auth: testAuth });
-        const names = toolkit.getToolNames();
-        // Should have at least some docs tools and API tools
-        expect(names.length).toBeGreaterThan(0);
-        // WixREADME is registered by default (getToKnowWixEnabled defaults to false in addDocsTools,
-        // but the toolkit passes authStrategy so it should still register docs tools)
-        expect(names).toContain('SearchWixRESTDocumentation');
-        expect(names).toContain('ReadFullDocsArticle');
-        expect(names).toContain('CallWixSiteAPI');
-        expect(names).toContain('ListWixSites');
-        expect(names).toContain('ManageWixSite');
-    });
-    test('registers only specified docs tools', () => {
-        const toolkit = createWixToolkit({
-            auth: testAuth,
-            docs: { tools: ['REST'] },
-            api: { tools: [] }
-        });
-        const names = toolkit.getToolNames();
-        expect(names).toContain('SearchWixRESTDocumentation');
-        expect(names).not.toContain('SearchWixSDKDocumentation');
-    });
-    test('registers only specified API tools', () => {
-        const toolkit = createWixToolkit({
-            auth: testAuth,
-            docs: { tools: [] },
-            api: { tools: ['CallWixSiteAPI'] }
-        });
-        const names = toolkit.getToolNames();
-        expect(names).toContain('CallWixSiteAPI');
-        expect(names).not.toContain('ListWixSites');
-        expect(names).not.toContain('ManageWixSite');
-    });
-    test('registers ExecuteWixAPI when requested with API tools', () => {
-        const toolkit = createWixToolkit({
-            auth: testAuth,
-            docs: { tools: [] },
-            api: { tools: ['CallWixSiteAPI', 'ExecuteWixAPI'] }
-        });
-        const names = toolkit.getToolNames();
-        expect(names).toContain('CallWixSiteAPI');
-        expect(names).toContain('ExecuteWixAPI');
-    });
-    test('preserves consumer ExecuteWixAPI description override', () => {
-        const toolkit = createWixToolkit({
-            auth: testAuth,
-            docs: { tools: [] },
-            api: {
-                tools: ['ExecuteWixAPI'],
-                toolDescriptions: { ExecuteWixAPI: 'custom execute description' }
-            }
-        });
-        expect(toolkit.getTool('ExecuteWixAPI')?.description).toBe('custom execute description');
-    });
-    test('exclude filters out tools', () => {
-        const toolkit = createWixToolkit({
-            auth: testAuth,
-            docs: { tools: ['REST'] },
-            api: { tools: ['CallWixSiteAPI', 'ListWixSites'] },
-            exclude: ['ListWixSites']
-        });
-        const names = toolkit.getToolNames();
-        expect(names).toContain('CallWixSiteAPI');
-        expect(names).not.toContain('ListWixSites');
-    });
-    test('getTool returns tool by name', () => {
-        const toolkit = createWixToolkit({
-            auth: testAuth,
-            docs: { tools: ['REST'] },
-            api: { tools: ['CallWixSiteAPI'] }
-        });
-        const tool = toolkit.getTool('CallWixSiteAPI');
-        expect(tool).toBeDefined();
-        expect(tool.name).toBe('CallWixSiteAPI');
-        expect(tool.description).toBeTruthy();
-        expect(tool.inputSchema).toBeDefined();
-        expect(typeof tool.execute).toBe('function');
-    });
-    test('SearchWixAPISpec sends the caller credential on the loopback call', async () => {
-        const fetchMock = vi
-            .spyOn(globalThis, 'fetch')
-            .mockImplementation(async () => Response.json({ result: 'ok' }));
-        const toolkit = createWixToolkit({
-            auth: testAuth,
-            docs: { tools: [] },
-            api: { tools: ['SearchWixAPISpec'] }
-        });
-        await toolkit
-            .getTool('SearchWixAPISpec')
-            .execute({ code: 'async () => 1', reason: 'test' });
-        const [url, init] = fetchMock.mock.calls.at(-1);
-        expect(url).toContain('/api/code-mode/search');
-        expect(init.headers).toMatchObject({
-            Authorization: 'Bearer test-account-token'
-        });
-        fetchMock.mockRestore();
-    });
-    test('getTool returns undefined for non-existent tool', () => {
-        const toolkit = createWixToolkit({
-            auth: testAuth,
-            docs: { tools: [] },
-            api: { tools: [] }
-        });
-        expect(toolkit.getTool('NonExistent')).toBeUndefined();
-    });
-    test('WixREADME is registered when getToKnowWixEnabled is true', () => {
-        const toolkit = createWixToolkit({
-            auth: testAuth,
-            docs: { tools: ['REST'], getToKnowWixEnabled: true },
-            api: { tools: [] }
-        });
-        expect(toolkit.getToolNames()).toContain('WixREADME');
-    });
-    test('WixREADME is not registered when getToKnowWixEnabled is false', () => {
-        const toolkit = createWixToolkit({
-            auth: testAuth,
-            docs: { tools: ['REST'], getToKnowWixEnabled: false },
-            api: { tools: [] }
-        });
-        expect(toolkit.getToolNames()).not.toContain('WixREADME');
-    });
-    test('GetSiteContext is registered when getToKnowWixEnabled is true', () => {
-        const toolkit = createWixToolkit({
-            auth: testAuth,
-            docs: { getToKnowWixEnabled: true },
-            api: { tools: [] }
-        });
-        expect(toolkit.getToolNames()).toContain('GetSiteContext');
-    });
-    test('GetSiteContext is registered regardless of getToKnowWixEnabled', () => {
-        const toolkit = createWixToolkit({
-            auth: testAuth,
-            docs: { getToKnowWixEnabled: false },
-            api: { tools: [] }
-        });
-        expect(toolkit.getToolNames()).toContain('GetSiteContext');
-    });
-    test('GetSiteContext is not registered when excluded', () => {
-        const toolkit = createWixToolkit({
-            auth: testAuth,
-            docs: { getToKnowWixEnabled: true },
-            api: { tools: [] },
-            exclude: ['GetSiteContext']
-        });
-        expect(toolkit.getToolNames()).not.toContain('GetSiteContext');
-    });
-    test('GetSiteContext is registered even when WixREADME is disabled', () => {
-        const toolkit = createWixToolkit({
-            auth: testAuth,
-            docs: { getToKnowWixEnabled: true },
-            api: { tools: [] },
-            exclude: ['WixREADME']
-        });
-        expect(toolkit.getToolNames()).toContain('GetSiteContext');
-    });
-});
-// ---------------------------------------------------------------------------
-// createWixToolkit - conversationId
-// ---------------------------------------------------------------------------
-describe('createWixToolkit() - conversationId', () => {
-    test('registers tools normally when conversationId is provided', () => {
-        const toolkit = createWixToolkit({
-            auth: testAuth,
-            docs: { tools: [] },
-            api: { tools: ['CallWixSiteAPI'] },
-            conversationId: 'conv-123'
-        });
-        expect(toolkit.getToolNames()).toContain('CallWixSiteAPI');
-    });
-    test('registers tools normally when conversationId is omitted', () => {
-        const toolkit = createWixToolkit({
-            auth: testAuth,
-            docs: { tools: [] },
-            api: { tools: ['CallWixSiteAPI'] }
-        });
-        expect(toolkit.getToolNames()).toContain('CallWixSiteAPI');
-    });
-});
-// ---------------------------------------------------------------------------
-// createWixToolkit - schema manipulation (defaults)
-// ---------------------------------------------------------------------------
-describe('createWixToolkit() - defaults', () => {
-    test('defaults removes field from inputSchema', () => {
-        const toolkit = createWixToolkit({
-            auth: testAuth,
-            docs: { tools: [] },
-            api: { tools: ['CallWixSiteAPI'] },
-            defaults: { siteId: 'my-site-id' }
-        });
-        const tool = toolkit.getTool('CallWixSiteAPI');
-        const shape = tool.inputSchema.shape;
-        // siteId should be removed from schema
-        expect(shape.siteId).toBeUndefined();
-        // Other fields should remain
-        expect(shape.url).toBeDefined();
-        expect(shape.method).toBeDefined();
-    });
-    test('defaults with empty value still removes field from schema', () => {
-        const toolkit = createWixToolkit({
-            auth: testAuth,
-            docs: { tools: [] },
-            api: { tools: ['CallWixSiteAPI'] },
-            defaults: { siteId: '' }
-        });
-        const tool = toolkit.getTool('CallWixSiteAPI');
-        const shape = tool.inputSchema.shape;
-        expect(shape.siteId).toBeUndefined();
-        expect(shape.url).toBeDefined();
-    });
-    test('defaults removes siteId from ExecuteWixAPI schema', () => {
-        const toolkit = createWixToolkit({
-            auth: testAuth,
-            docs: { tools: [] },
-            api: { tools: ['ExecuteWixAPI'] },
-            defaults: { siteId: 'my-site-id' }
-        });
-        const tool = toolkit.getTool('ExecuteWixAPI');
-        const shape = tool.inputSchema.shape;
-        expect(shape.siteId).toBeUndefined();
-        expect(shape.code).toBeDefined();
-        expect(shape.reason).toBeDefined();
-        expect(shape.hasMutations).toBeDefined();
-    });
-});
-// ---------------------------------------------------------------------------
-// createWixToolkit - auth normalization
-// ---------------------------------------------------------------------------
-describe('createWixToolkit() - auth', () => {
-    test('accepts McpAuthenticationStrategy directly', () => {
-        const strategy = {
-            getSiteAuthHeaders: async () => ({ Authorization: 'Bearer token' }),
-            getAccountAuthHeaders: async () => ({ Authorization: 'Bearer token' })
-        };
-        // Should not throw -- create toolkit with no tools
-        const toolkit = createWixToolkit({
-            auth: strategy,
-            docs: { tools: [] },
-            api: { tools: [] },
-            exclude: [
-                'BrowseWixRESTDocsMenu',
-                'ReadFullDocsArticle',
-                'ReadFullDocsMethodSchema',
-                'CreateWixBusinessGuide',
-                'GetSiteContext'
-            ]
-        });
-        expect(toolkit.getTools()).toHaveLength(0);
-    });
-    test('accepts siteToken/accountToken functions', () => {
-        // Should not throw
-        const toolkit = createWixToolkit({
-            auth: {
-                siteToken: async () => ({ Authorization: 'Bearer site' }),
-                accountToken: async () => ({ Authorization: 'Bearer account' })
-            },
-            docs: { tools: [] },
-            api: { tools: [] },
-            exclude: [
-                'BrowseWixRESTDocsMenu',
-                'ReadFullDocsArticle',
-                'ReadFullDocsMethodSchema',
-                'CreateWixBusinessGuide',
-                'GetSiteContext'
-            ]
-        });
-        expect(toolkit.getTools()).toHaveLength(0);
-    });
-});
-// ---------------------------------------------------------------------------
-// createWixToolkit - error flows (errorBody)
-// ---------------------------------------------------------------------------
-const mockHttpRequest = vi.hoisted(() => vi.fn());
-vi.mock('@wix/http-client', async (importOriginal) => {
-    const original = await importOriginal();
-    const MockHttpClient = vi
-        .fn()
-        .mockImplementation(() => ({ request: mockHttpRequest }));
-    MockHttpClient.isHttpError = vi.fn().mockReturnValue(false);
-    return { ...original, HttpClient: MockHttpClient };
-});
-describe('createWixToolkit() - error flows', () => {
-    beforeEach(() => mockHttpRequest.mockReset());
-    test('afterExecute receives isError result with content when tool returns a controlled error', async () => {
-        const afterExecute = vi.fn();
-        const toolkit = createWixToolkit({
-            auth: testAuth,
-            docs: { tools: [] },
-            api: { tools: ['CallWixSiteAPI'] },
-            defaults: { siteId: 'test-site' },
-            hooks: { afterExecute }
-        });
-        // HTML response triggers CallWixSiteAPI to return { isError: true } without throwing
-        mockHttpRequest.mockResolvedValue({
-            status: 200,
-            headers: {},
-            data: '<!DOCTYPE html><html><body>Login page</body></html>'
-        });
-        const result = await toolkit.getTool('CallWixSiteAPI').execute({
-            url: 'https://www.wixapis.com/test',
-            method: 'GET',
-            reason: 'test'
-        });
-        expect(result.isError).toBe(true);
-        expect(extractText(result)).toMatch(/HTML/);
-        expect(afterExecute).toHaveBeenCalledWith('CallWixSiteAPI', expect.objectContaining({ isError: true }), expect.any(Number));
-    });
-    test('onError is called with exception message when tool throws', async () => {
-        const onError = vi.fn();
-        const toolkit = createWixToolkit({
-            // siteToken throwing causes the tool callback to throw before any HTTP call
-            auth: {
-                siteToken: async () => {
-                    throw new Error('Auth failed');
-                },
-                accountToken: async () => ({ Authorization: 'Bearer test' })
-            },
-            docs: { tools: [] },
-            api: { tools: ['CallWixSiteAPI'] },
-            defaults: { siteId: 'test-site' },
-            hooks: { onError }
-        });
-        const result = await toolkit.getTool('CallWixSiteAPI').execute({
-            url: 'https://www.wixapis.com/test',
-            method: 'GET',
-            reason: 'test'
-        });
-        expect(result.isError).toBe(true);
-        expect(extractText(result)).toMatch(/Auth failed/);
-        expect(onError).toHaveBeenCalledWith('CallWixSiteAPI', expect.objectContaining({
-            message: expect.stringContaining('Auth failed')
-        }), expect.any(Number));
-    });
-});
-// ---------------------------------------------------------------------------
-// createWixToolkit - hooks
-// ---------------------------------------------------------------------------
-describe('createWixToolkit() - hooks', () => {
-    test('beforeExecute hook is called with tool name and args', async () => {
-        const beforeExecute = vi.fn();
-        const toolkit = createWixToolkit({
-            auth: testAuth,
-            docs: { tools: ['REST'], getToKnowWixEnabled: true },
-            api: { tools: [] },
-            hooks: { beforeExecute }
-        });
-        const readmeTool = toolkit.getTool('WixREADME');
-        if (readmeTool) {
-            // Execute will likely fail (network), but beforeExecute should still fire
-            await readmeTool.execute({}).catch(() => { });
-            expect(beforeExecute).toHaveBeenCalledWith('WixREADME', {});
-        }
-    });
-});
-// ---------------------------------------------------------------------------
-// createWixToolkit - preloadReadme
-// ---------------------------------------------------------------------------
-describe('createWixToolkit() - preloadReadme', () => {
-    test('returns null when WixREADME is not registered', async () => {
-        const toolkit = createWixToolkit({
-            auth: testAuth,
-            docs: { tools: ['REST'], getToKnowWixEnabled: false },
-            api: { tools: [] }
-        });
-        const result = await toolkit.preloadReadme();
-        expect(result).toBeNull();
-    });
-    test('preloadReadme() returns static README content even when getDynamicContext fails', async () => {
-        const { getDynamicContext } = await import('@wix/dynamic-context-enricher');
-        vi.mocked(getDynamicContext).mockRejectedValue(new Error('permission denied'));
-        const toolkit = createWixToolkit({
-            auth: testAuth,
-            docs: { getToKnowWixEnabled: true },
-            api: { tools: [] }
-        });
-        const result = await toolkit.preloadReadme();
-        expect(result).not.toBeNull();
-    });
-    test('WixREADME injects account-wide dynamic context when dynamicContextEnabled', async () => {
-        const { getDynamicContext } = await import('@wix/dynamic-context-enricher');
-        vi.mocked(getDynamicContext).mockReset();
-        vi.mocked(getDynamicContext).mockResolvedValue('# My Wix Sites Context');
-        const toolkit = createWixToolkit({
-            auth: testAuth,
-            docs: { getToKnowWixEnabled: true, dynamicContextEnabled: true },
-            api: { tools: [] }
-        });
-        const result = await toolkit.preloadReadme();
-        expect(result).toContain('# My Wix Sites Context');
-        // No specific site targeted → account-wide (undefined filter).
-        expect(vi.mocked(getDynamicContext)).toHaveBeenCalledWith(expect.anything(), expect.anything(), undefined, {
-            partnerContextEnabled: true,
-            includeAccountContext: true
-        });
-    });
-    test('preloadReadme() uses execute-aware README when ExecuteWixAPI is requested', async () => {
-        const toolkit = createWixToolkit({
-            auth: testAuth,
-            docs: { getToKnowWixEnabled: true },
-            api: { tools: ['ExecuteWixAPI'] }
-        });
-        const result = await toolkit.preloadReadme();
-        expect(result).toContain('ExecuteWixAPI');
-        expect(result).toContain('a single invocation can chain');
-    });
-    test('preloadReadme() preserves consumer readmeDocs override', async () => {
-        const toolkit = createWixToolkit({
-            auth: testAuth,
-            docs: {
-                getToKnowWixEnabled: true,
-                readmeDocs: [{ action: 'text', content: 'custom README content' }]
-            },
-            api: { tools: ['ExecuteWixAPI'] }
-        });
-        const result = await toolkit.preloadReadme();
-        expect(result).toContain('custom README content');
-        expect(result).not.toContain('a single invocation can chain');
-    });
-    test('preloadReadme() injects defaults.siteId into WixREADME execution', async () => {
-        const beforeExecute = vi.fn();
-        const toolkit = createWixToolkit({
-            auth: testAuth,
-            docs: { tools: [], getToKnowWixEnabled: true },
-            api: { tools: [] },
-            defaults: { siteId: 'a3f5e8d1-4b2c-4a9f-b6e7-1c8d9a0f2b3e' },
-            hooks: { beforeExecute }
-        });
-        // preloadReadme() passes no args, but defaults merge should inject siteId
-        await toolkit.preloadReadme();
-        expect(beforeExecute).toHaveBeenCalledWith('WixREADME', {
-            siteId: 'a3f5e8d1-4b2c-4a9f-b6e7-1c8d9a0f2b3e'
-        });
-    });
-});
-// ---------------------------------------------------------------------------
-// createWixToolkit - preloadDynamicContext
-// ---------------------------------------------------------------------------
-describe('createWixToolkit() - preloadDynamicContext', () => {
-    test('preloadDynamicContext() passes defaults context to getDynamicContext', async () => {
-        const { getDynamicContext } = await import('./docs/get-to-know.js');
-        const mockedGetDynamicContext = vi.mocked(getDynamicContext);
-        mockedGetDynamicContext.mockResolvedValue('dynamic context result');
-        const toolkit = createWixToolkit({
-            auth: testAuth,
-            docs: {
-                tools: [],
-                partnerContextEnabled: true
-            },
-            api: { tools: [] },
-            defaults: {
-                siteId: 'a3f5e8d1-4b2c-4a9f-b6e7-1c8d9a0f2b3e'
-            }
-        });
-        const result = await toolkit.preloadDynamicContext();
-        expect(result).toBe('dynamic context result');
-        expect(mockedGetDynamicContext).toHaveBeenCalledWith(expect.anything(), expect.anything(), {
-            siteId: 'a3f5e8d1-4b2c-4a9f-b6e7-1c8d9a0f2b3e'
-        }, {
-            partnerContextEnabled: true,
-            includeAccountContext: true
-        });
-    });
-});
-// ---------------------------------------------------------------------------
-// GetSiteContext tool behaviour
-// ---------------------------------------------------------------------------
-describe('GetSiteContext tool', () => {
-    const getSiteContextTool = () => {
-        const toolkit = createWixToolkit({
-            auth: testAuth,
-            docs: { getToKnowWixEnabled: true },
-            api: { tools: [] }
-        });
-        return toolkit.getTool('GetSiteContext');
-    };
-    test('passes siteId filter to getDynamicContext', async () => {
-        const { getDynamicContext } = await import('@wix/dynamic-context-enricher');
-        vi.mocked(getDynamicContext).mockResolvedValue('site context');
-        await getSiteContextTool().execute({ siteId: 'site-123' });
-        expect(vi.mocked(getDynamicContext)).toHaveBeenCalledWith(expect.anything(), expect.anything(), { siteId: 'site-123' }, {
-            partnerContextEnabled: false,
-            includeAccountContext: false
-        });
-    });
-    test('passes siteName filter to getDynamicContext', async () => {
-        const { getDynamicContext } = await import('@wix/dynamic-context-enricher');
-        vi.mocked(getDynamicContext).mockResolvedValue('site context');
-        await getSiteContextTool().execute({ siteName: 'My Site' });
-        expect(vi.mocked(getDynamicContext)).toHaveBeenCalledWith(expect.anything(), expect.anything(), { siteName: 'My Site' }, {
-            partnerContextEnabled: false,
-            includeAccountContext: false
-        });
-    });
-    test('returns error when neither siteId nor siteName is provided', async () => {
-        const { getDynamicContext } = await import('@wix/dynamic-context-enricher');
-        vi.mocked(getDynamicContext).mockClear();
-        const result = await getSiteContextTool().execute({});
-        expect(extractText(result)).toBe('Provide either siteId or siteName to identify the site.');
-        expect(vi.mocked(getDynamicContext)).not.toHaveBeenCalled();
-    });
-    test('returns context text on success', async () => {
-        const { getDynamicContext } = await import('@wix/dynamic-context-enricher');
-        vi.mocked(getDynamicContext).mockResolvedValue('## Site: My Site\nApps: Stores');
-        const result = await getSiteContextTool().execute({ siteId: 'site-123' });
-        expect(extractText(result)).toBe('## Site: My Site\nApps: Stores');
-    });
-    test('returns "No context found" when getDynamicContext returns empty string', async () => {
-        const { getDynamicContext } = await import('@wix/dynamic-context-enricher');
-        vi.mocked(getDynamicContext).mockResolvedValue('');
-        const result = await getSiteContextTool().execute({ siteId: 'site-123' });
-        expect(extractText(result)).toBe('No context found for the specified site.');
-    });
-    test('returns error message when getDynamicContext throws a non-auth error', async () => {
-        const { getDynamicContext } = await import('@wix/dynamic-context-enricher');
-        vi.mocked(getDynamicContext).mockRejectedValue(new Error('upstream timeout'));
-        const result = await getSiteContextTool().execute({ siteId: 'site-123' });
-        expect(extractText(result)).toContain('upstream timeout');
-    });
-    test('surfaces unauthorized errors as isError with error message', async () => {
-        const { getDynamicContext } = await import('@wix/dynamic-context-enricher');
-        const { UNAUTHORIZED_ERROR_NAME } = await import('./auth/index.js');
-        const authErr = Object.assign(new Error('session revoked'), {
-            name: UNAUTHORIZED_ERROR_NAME
-        });
-        vi.mocked(getDynamicContext).mockRejectedValue(authErr);
-        const result = await getSiteContextTool().execute({ siteId: 'site-123' });
-        expect(result.isError).toBe(true);
-        expect(extractText(result)).toContain('session revoked');
-    });
-});
-// ---------------------------------------------------------------------------
-// createWixToolkit - includeReadmeMentions
-// ---------------------------------------------------------------------------
-describe('createWixToolkit() - includeReadmeMentions', () => {
-    const makeToolkit = (includeReadmeMentions) => createWixToolkit({
-        auth: testAuth,
-        docs: { tools: ['REST'] },
-        api: { tools: ['CallWixSiteAPI', 'ExecuteWixAPI', 'SearchWixAPISpec'] },
-        ...(includeReadmeMentions === undefined ? {} : { includeReadmeMentions })
-    });
-    test('defaults to scrubbing WixREADME mentions from descriptions', () => {
-        const toolkit = makeToolkit();
-        expect(toolkit.getTool('CallWixSiteAPI').description).not.toContain('WixREADME');
-        const restDesc = toolkit.getTool('SearchWixRESTDocumentation').description;
-        expect(restDesc).not.toContain('WixREADME');
-        expect(restDesc).not.toContain('MANDATORY FIRST STEP');
-        // Body content is preserved.
-        expect(toolkit.getTool('CallWixSiteAPI').description).toContain('SearchWixRESTDocumentation');
-    });
-    test('includeReadmeMentions:true keeps WixREADME mentions (matches server text)', async () => {
-        const { defaultToolDescriptions } = await import('./config/default-config.js');
-        const toolkit = makeToolkit(true);
-        expect(toolkit.getTool('CallWixSiteAPI').description).toContain('WixREADME');
-        // Byte-for-byte identical to the canonical server description.
-        expect(toolkit.getTool('CallWixSiteAPI').description).toBe(defaultToolDescriptions.CallWixSiteAPI);
-    });
-    test('code-mode ExecuteWixAPI/SearchWixAPISpec are scrubbed by default', () => {
-        const toolkit = makeToolkit();
-        expect(toolkit.getTool('ExecuteWixAPI').description).not.toContain('WixREADME');
-        expect(toolkit.getTool('SearchWixAPISpec').description).not.toContain('WixREADME');
-    });
-    test('consumer description override wins even when scrubbing', () => {
-        const toolkit = createWixToolkit({
-            auth: testAuth,
-            docs: { tools: [] },
-            api: {
-                tools: ['CallWixSiteAPI'],
-                toolDescriptions: { CallWixSiteAPI: 'custom call description' }
-            }
-            // includeReadmeMentions omitted -> false
-        });
-        expect(toolkit.getTool('CallWixSiteAPI').description).toBe('custom call description');
-    });
-    test("WixREADME's own description is left untouched when scrubbing", () => {
-        const toolkit = createWixToolkit({
-            auth: testAuth,
-            docs: { tools: ['REST'], getToKnowWixEnabled: true },
-            api: { tools: [] }
-            // includeReadmeMentions omitted -> false
-        });
-        // The flag scrubs OTHER tools' descriptions; the WixREADME tool, if present,
-        // keeps its self-describing default text.
-        expect(toolkit.getTool('WixREADME').description).toContain('MANDATORY FIRST STEP');
-    });
-});
-//# sourceMappingURL=toolkit.test.js.map