@demigodmode/pi-web-agent 0.2.1 → 0.2.2

package/dist/tests/cache/ttl-cache.test.js

@@ -0,0 +1,19 @@
+import { describe, expect, it } from 'vitest';
+import { createTtlCache } from '../../src/cache/ttl-cache.js';
+describe('TTL cache', () => {
+    it('returns cached values before expiry', () => {
+        let now = 1_000;
+        const cache = createTtlCache({ ttlMs: 100, now: () => now });
+        cache.set('key', 'value');
+        expect(cache.get('key')).toBe('value');
+        now = 1_050;
+        expect(cache.get('key')).toBe('value');
+    });
+    it('drops cached values after expiry', () => {
+        let now = 1_000;
+        const cache = createTtlCache({ ttlMs: 100, now: () => now });
+        cache.set('key', 'value');
+        now = 1_101;
+        expect(cache.get('key')).toBeUndefined();
+    });
+});

package/dist/tests/contracts.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/tests/contracts.test.js

@@ -0,0 +1,65 @@
+import { describe, expect, it } from 'vitest';
+import { TOOL_STATUSES } from '../src/types.js';
+import extension from '../src/extension.js';
+describe('shared tool contracts', () => {
+    it('exposes the allowed tool statuses', () => {
+        expect(TOOL_STATUSES).toEqual([
+            'ok',
+            'needs_headless',
+            'blocked',
+            'unsupported',
+            'error'
+        ]);
+    });
+    it('allows normalized search results', () => {
+        const result = {
+            title: 'Example',
+            url: 'https://example.com',
+            snippet: 'Example snippet'
+        };
+        expect(result.url).toContain('https://');
+    });
+    it('shapes search and fetch responses around status + metadata', () => {
+        const search = {
+            status: 'ok',
+            results: [],
+            metadata: { backend: 'duckduckgo', cacheHit: false }
+        };
+        const fetch = {
+            status: 'needs_headless',
+            url: 'https://example.com',
+            metadata: { method: 'http', cacheHit: false }
+        };
+        const headless = {
+            status: 'error',
+            url: 'https://example.com',
+            metadata: { method: 'headless', cacheHit: false },
+            error: { code: 'NOT_IMPLEMENTED', message: 'stub' }
+        };
+        expect(search.status).toBe('ok');
+        expect(fetch.status).toBe('needs_headless');
+        expect(headless.metadata.method).toBe('headless');
+    });
+});
+describe('extension surface', () => {
+    it('exports a Pi extension function', () => {
+        expect(typeof extension).toBe('function');
+    });
+});
+describe('headless metadata', () => {
+    it('allows headless metadata to carry browser and navigation timing', () => {
+        const headless = {
+            status: 'ok',
+            url: 'https://example.com',
+            metadata: {
+                method: 'headless',
+                cacheHit: false,
+                browser: 'chrome',
+                navigationMs: 1500
+            },
+            content: { text: 'Rendered text' }
+        };
+        expect(headless.metadata.browser).toBe('chrome');
+        expect(headless.metadata.navigationMs).toBe(1500);
+    });
+});

package/dist/tests/extension.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/tests/extension.test.js

@@ -0,0 +1,123 @@
+import { describe, expect, it, vi } from 'vitest';
+import extension from '../src/extension.js';
+describe('Pi extension entrypoint', () => {
+    it('registers four tools with Pi', () => {
+        const registerTool = vi.fn();
+        const pi = { registerTool, on: vi.fn() };
+        extension(pi);
+        expect(registerTool).toHaveBeenCalledTimes(4);
+        expect(registerTool.mock.calls.map((call) => call[0].name)).toEqual([
+            'web_search',
+            'web_fetch',
+            'web_fetch_headless',
+            'web_explore'
+        ]);
+    });
+    it('describes web_explore as the preferred tool for research-style web questions', () => {
+        const registerTool = vi.fn();
+        const pi = { registerTool, on: vi.fn() };
+        extension(pi);
+        const tools = registerTool.mock.calls.map((call) => call[0]);
+        const webExplore = tools.find((tool) => tool.name === 'web_explore');
+        expect(webExplore).toBeDefined();
+        expect(webExplore.description).toContain('Prefer this for multi-source web research');
+        expect(webExplore.description).toContain('current docs/discussion lookups');
+        expect(webExplore.description).toContain('Use this instead of chaining low-level web tools');
+        expect(webExplore.parameters.properties).toHaveProperty('query');
+        expect(Object.keys(webExplore.parameters.properties)).toEqual(['query']);
+    });
+    it('describes low-level tools as direct/manual tools and points research prompts to web_explore', () => {
+        const registerTool = vi.fn();
+        const pi = { registerTool, on: vi.fn() };
+        extension(pi);
+        const tools = registerTool.mock.calls.map((call) => call[0]);
+        const webSearch = tools.find((tool) => tool.name === 'web_search');
+        const webFetch = tools.find((tool) => tool.name === 'web_fetch');
+        const webFetchHeadless = tools.find((tool) => tool.name === 'web_fetch_headless');
+        expect(webSearch.description).toContain('Direct search tool for manual discovery');
+        expect(webSearch.description).toContain('Prefer web_explore for broader research questions');
+        expect(webFetch.description).toContain('Direct HTTP page fetch for a specific URL');
+        expect(webFetch.description).toContain('Prefer web_explore for broader research across multiple sources');
+        expect(webFetchHeadless.description).toContain('Direct headless page fetch for a specific URL');
+        expect(webFetchHeadless.description).toContain('Prefer web_explore for research tasks');
+    });
+    it('adds a short research hint that prefers web_explore for multi-source web questions', async () => {
+        const handlers = new Map();
+        const pi = {
+            registerTool: vi.fn(),
+            on: vi.fn((eventName, handler) => {
+                handlers.set(eventName, handler);
+            })
+        };
+        extension(pi);
+        const beforeAgentStart = handlers.get('before_agent_start');
+        expect(beforeAgentStart).toBeDefined();
+        const result = await beforeAgentStart({
+            prompt: 'Find current docs or discussions about Playwright launching an installed Chrome or Edge executable instead of a bundled browser, then summarize the recommended approach.',
+            images: [],
+            systemPrompt: 'Base system prompt'
+        }, {});
+        expect(result.systemPrompt).toContain('prefer web_explore');
+        expect(result.systemPrompt).toContain('finding and comparing multiple sources');
+        expect(result.systemPrompt).toContain('Use web_search, web_fetch, and web_fetch_headless for direct/manual operations');
+        expect(result.systemPrompt).toContain('After using web_explore, only call low-level web tools if there is a specific unresolved gap');
+        expect(result.systemPrompt).toContain('Do not keep searching or fetching just for extra confirmation');
+    });
+    it('does not register a context hook that injects reminder text into the visible session', () => {
+        const handlers = new Map();
+        const pi = {
+            registerTool: vi.fn(),
+            on: vi.fn((eventName, handler) => {
+                handlers.set(eventName, handler);
+            })
+        };
+        extension(pi);
+        expect(handlers.has('context')).toBe(false);
+    });
+    it('returns human-readable content for web_explore instead of only raw json', async () => {
+        const tools = [];
+        const pi = {
+            registerTool: (tool) => tools.push(tool),
+            on: vi.fn()
+        };
+        extension(pi);
+        const webExplore = tools.find((tool) => tool.name === 'web_explore');
+        const result = await webExplore.execute('tool-call-1', {
+            query: 'example query'
+        });
+        expect(result.content[0].text).toContain('Findings');
+        expect(result.content[0].text).toContain('Sources');
+    }, 15000);
+    it('blocks low-level web_search after a successful web_explore in the same tool flow', async () => {
+        const tools = [];
+        const pi = {
+            registerTool: (tool) => tools.push(tool),
+            on: vi.fn()
+        };
+        extension(pi);
+        const webExplore = tools.find((tool) => tool.name === 'web_explore');
+        const webSearch = tools.find((tool) => tool.name === 'web_search');
+        await webExplore.execute('tool-call-1', { query: 'example query' });
+        const result = await webSearch.execute('tool-call-2', { query: 'follow-up search' });
+        expect(result.isError).toBe(true);
+        expect(result.details).toMatchObject({
+            status: 'error',
+            error: {
+                code: 'POST_WEB_EXPLORE_GUARD',
+                message: 'web_explore already ran for this research task. Only use low-level web tools if there is a specific unresolved gap.'
+            }
+        });
+    }, 15000);
+    it('still allows low-level tools before web_explore runs', async () => {
+        const tools = [];
+        const pi = {
+            registerTool: (tool) => tools.push(tool),
+            on: vi.fn()
+        };
+        extension(pi);
+        const webSearch = tools.find((tool) => tool.name === 'web_search');
+        const result = await webSearch.execute('tool-call-1', { query: 'plain search' });
+        expect(result.details.status).not.toBe('error');
+        expect(result.details.error?.code).not.toBe('POST_WEB_EXPLORE_GUARD');
+    }, 15000);
+});

package/dist/tests/extract/readability.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/tests/extract/readability.test.js

@@ -0,0 +1,79 @@
+import { describe, expect, it } from 'vitest';
+import { extractReadableContent, extractReadableContentSafely } from '../../src/extract/readability.js';
+describe('readability extraction', () => {
+    it('extracts readable text from article-like HTML', () => {
+        const result = extractReadableContent(`
+      <html>
+        <head><title>Example Title</title></head>
+        <body>
+          <article>
+            <h1>Example Title</h1>
+            <p>First paragraph.</p>
+            <p>Second paragraph.</p>
+          </article>
+        </body>
+      </html>
+    `);
+        expect(result).toMatchObject({
+            title: 'Example Title',
+            text: expect.stringContaining('First paragraph.')
+        });
+    });
+    it('truncates long extracted text', () => {
+        const result = extractReadableContent(`
+      <html><body><article><p>${'word '.repeat(200)}</p></article></body></html>
+    `, 50);
+        expect(result.text.length).toBeLessThanOrEqual(50);
+    });
+    it('falls back to lightweight extraction when stylesheet parsing breaks the primary path', () => {
+        const result = extractReadableContentSafely(`
+      <html>
+        <head>
+          <title>Broken CSS Page</title>
+          <style>
+            .btn {
+              color: red;
+              &:hover {
+                color: blue;
+              }
+            }
+          </style>
+        </head>
+        <body>
+          <main>
+            <h1>Broken CSS Page</h1>
+            <p>This content should still be recoverable even if JSDOM rejects the stylesheet.</p>
+            <p>The fallback path should keep this text readable.</p>
+          </main>
+        </body>
+      </html>
+    `);
+        expect(result.mode).toBe('fallback');
+        expect(result.content.title).toBe('Broken CSS Page');
+        expect(result.content.text).toContain('This content should still be recoverable');
+        expect(result.content.text).not.toContain('color: red');
+    });
+    it('returns fallback text from body content when main/article tags are missing', () => {
+        const result = extractReadableContentSafely(`
+      <html>
+        <head>
+          <title>Body Fallback</title>
+          <style>
+            .card {
+              &:hover {
+                opacity: 1;
+              }
+            }
+          </style>
+        </head>
+        <body>
+          <div>First useful paragraph with enough readable content to keep.</div>
+          <div>Second useful paragraph that should also survive fallback extraction.</div>
+        </body>
+      </html>
+    `);
+        expect(result.mode).toBe('fallback');
+        expect(result.content.title).toBe('Body Fallback');
+        expect(result.content.text).toContain('First useful paragraph');
+    });
+});

package/dist/tests/fetch/browser-resolution.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/tests/fetch/browser-resolution.test.js

@@ -0,0 +1,37 @@
+import { describe, expect, it, vi } from 'vitest';
+import { resolveBrowserExecutable } from '../../src/fetch/browser-resolution.js';
+describe('browser resolution', () => {
+    it('prefers an explicit configured browser path', async () => {
+        const result = await resolveBrowserExecutable({
+            configuredPath: 'C:/Browsers/Chrome/chrome.exe',
+            fileExists: vi.fn(async (path) => path === 'C:/Browsers/Chrome/chrome.exe')
+        });
+        expect(result).toEqual({
+            ok: true,
+            executablePath: 'C:/Browsers/Chrome/chrome.exe',
+            browser: 'configured'
+        });
+    });
+    it('falls back to detected Windows Chrome before Edge', async () => {
+        const result = await resolveBrowserExecutable({
+            fileExists: vi.fn(async (path) => path === 'C:/Program Files/Google/Chrome/Application/chrome.exe')
+        });
+        expect(result).toEqual({
+            ok: true,
+            executablePath: 'C:/Program Files/Google/Chrome/Application/chrome.exe',
+            browser: 'chrome'
+        });
+    });
+    it('returns a structured startup error when no browser exists', async () => {
+        const result = await resolveBrowserExecutable({
+            fileExists: vi.fn(async () => false)
+        });
+        expect(result).toEqual({
+            ok: false,
+            error: {
+                code: 'BROWSER_NOT_FOUND',
+                message: 'No compatible local browser was found for headless fetch.'
+            }
+        });
+    });
+});

package/dist/tests/fetch/headless-fetch.smoke.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/tests/fetch/headless-fetch.smoke.test.js

@@ -0,0 +1,17 @@
+import { describe, expect, it } from 'vitest';
+import { resolveBrowserExecutable } from '../../src/fetch/browser-resolution.js';
+import { headlessFetch } from '../../src/fetch/headless-fetch.js';
+const runSmoke = process.env.PI_HEADLESS_SMOKE === '1';
+describe.skipIf(!runSmoke)('headless fetch smoke', () => {
+    it('launches a local browser when one is available', async () => {
+        const resolved = await resolveBrowserExecutable({});
+        expect(resolved.ok).toBe(true);
+        if (!resolved.ok)
+            return;
+        const result = await headlessFetch('https://example.com', {
+            configuredPath: resolved.executablePath
+        });
+        expect(['ok', 'blocked']).toContain(result.status);
+        expect(result.metadata.method).toBe('headless');
+    }, 30000);
+});

package/dist/tests/fetch/headless-fetch.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/tests/fetch/headless-fetch.test.js

@@ -0,0 +1,150 @@
+import { describe, expect, it, vi } from 'vitest';
+import { headlessFetch } from '../../src/fetch/headless-fetch.js';
+describe('headless fetch', () => {
+    it('returns a startup error when no browser can be resolved', async () => {
+        const result = await headlessFetch('https://example.com', {
+            resolveBrowser: vi.fn().mockResolvedValue({
+                ok: false,
+                error: {
+                    code: 'BROWSER_NOT_FOUND',
+                    message: 'No compatible local browser was found for headless fetch.'
+                }
+            })
+        });
+        expect(result).toMatchObject({
+            status: 'error',
+            error: { code: 'BROWSER_NOT_FOUND' },
+            metadata: { method: 'headless', cacheHit: false }
+        });
+    });
+    it('extracts rendered page content and includes navigation metadata', async () => {
+        const closePage = vi.fn(async () => undefined);
+        const closeContext = vi.fn(async () => undefined);
+        const closeBrowser = vi.fn(async () => undefined);
+        const page = {
+            goto: vi.fn(async () => undefined),
+            waitForLoadState: vi.fn(async () => undefined),
+            content: vi.fn(async () => '<html><body><article><p>Rendered text with enough content to pass extraction.</p></article></body></html>'),
+            close: closePage
+        };
+        const context = {
+            newPage: vi.fn(async () => page),
+            close: closeContext
+        };
+        const browser = {
+            newContext: vi.fn(async () => context),
+            close: closeBrowser
+        };
+        const result = await headlessFetch('https://example.com', {
+            resolveBrowser: vi.fn().mockResolvedValue({
+                ok: true,
+                executablePath: 'C:/Program Files/Google/Chrome/Application/chrome.exe',
+                browser: 'chrome'
+            }),
+            launchBrowser: vi.fn(async () => browser),
+            now: vi.fn()
+                .mockReturnValueOnce(1000)
+                .mockReturnValueOnce(2600)
+        });
+        expect(result.status).toBe('ok');
+        expect(result.metadata.method).toBe('headless');
+        expect(result.metadata.browser).toBe('chrome');
+        expect(result.metadata.navigationMs).toBe(1600);
+        expect(result.content?.text).toContain('Rendered text');
+        expect(closePage).toHaveBeenCalledTimes(1);
+        expect(closeContext).toHaveBeenCalledTimes(1);
+        expect(closeBrowser).toHaveBeenCalledTimes(1);
+    });
+    it('still cleans up browser resources when navigation fails', async () => {
+        const closePage = vi.fn(async () => undefined);
+        const closeContext = vi.fn(async () => undefined);
+        const closeBrowser = vi.fn(async () => undefined);
+        const page = {
+            goto: vi.fn(async () => {
+                throw new Error('navigation failed');
+            }),
+            waitForLoadState: vi.fn(async () => undefined),
+            content: vi.fn(async () => ''),
+            close: closePage
+        };
+        const context = {
+            newPage: vi.fn(async () => page),
+            close: closeContext
+        };
+        const browser = {
+            newContext: vi.fn(async () => context),
+            close: closeBrowser
+        };
+        const result = await headlessFetch('https://example.com', {
+            resolveBrowser: vi.fn().mockResolvedValue({
+                ok: true,
+                executablePath: 'C:/Program Files/Google/Chrome/Application/chrome.exe',
+                browser: 'chrome'
+            }),
+            launchBrowser: vi.fn(async () => browser)
+        });
+        expect(result).toMatchObject({
+            status: 'error',
+            error: { code: 'HEADLESS_NAVIGATION_FAILED' }
+        });
+        expect(closePage).toHaveBeenCalledTimes(1);
+        expect(closeContext).toHaveBeenCalledTimes(1);
+        expect(closeBrowser).toHaveBeenCalledTimes(1);
+    });
+    it('uses safe extraction for rendered pages with broken stylesheet content', async () => {
+        const result = await headlessFetch('https://example.com/broken-css', {
+            resolveBrowser: vi.fn().mockResolvedValue({
+                ok: true,
+                browser: 'edge',
+                executablePath: 'C:/Program Files/Microsoft/Edge/Application/msedge.exe'
+            }),
+            launchBrowser: vi.fn(async () => ({
+                newContext: async () => ({
+                    newPage: async () => ({
+                        goto: async () => undefined,
+                        waitForLoadState: async () => undefined,
+                        content: async () => `
+              <html>
+                <head>
+                  <title>Broken CSS Page</title>
+                  <style>
+                    .btn {
+                      color: red;
+                      &:hover {
+                        color: blue;
+                      }
+                    }
+                  </style>
+                </head>
+                <body>
+                  <main>
+                    <h1>Broken CSS Page</h1>
+                    <p>Main content starts here.</p>
+                    <p>Show more Show more Show more Show more</p>
+                    <p>Useful details for the user.</p>
+                    <p>Privacy Terms Privacy Terms Privacy Terms</p>
+                  </main>
+                </body>
+              </html>
+            `,
+                        close: async () => undefined
+                    }),
+                    close: async () => undefined
+                }),
+                close: async () => undefined
+            })),
+            now: (() => {
+                let tick = 0;
+                return () => (tick += 100);
+            })()
+        });
+        expect(result.status).toBe('ok');
+        if (result.status !== 'ok' || !result.content)
+            return;
+        expect(result.content.title).toBe('Broken CSS Page');
+        expect(result.content.text).toContain('Main content starts here.');
+        expect(result.content.text).toContain('Useful details for the user.');
+        expect(result.content.text.match(/Show more/g)?.length ?? 0).toBeLessThan(4);
+        expect(result.content.text.match(/Privacy Terms/g)?.length ?? 0).toBeLessThan(3);
+    });
+});

package/dist/tests/fetch/http-fetch.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/tests/fetch/http-fetch.test.js

@@ -0,0 +1,129 @@
+import { describe, expect, it, vi } from 'vitest';
+import { createHttpFetcher } from '../../src/fetch/http-fetch.js';
+describe('http fetcher', () => {
+    it('returns ok for clearly readable HTML', async () => {
+        const fetcher = createHttpFetcher({
+            fetchImpl: vi.fn().mockResolvedValue({
+                ok: true,
+                url: 'https://example.com/article',
+                headers: new Headers({ 'content-type': 'text/html' }),
+                text: async () => '<html><body><article><p>Readable article text with enough content to look solid.</p></article></body></html>'
+            })
+        });
+        const result = await fetcher('https://example.com/article');
+        expect(result.status).toBe('ok');
+        expect(result.metadata.method).toBe('http');
+    });
+    it('returns needs_headless for weak script-shell pages', async () => {
+        const fetcher = createHttpFetcher({
+            fetchImpl: vi.fn().mockResolvedValue({
+                ok: true,
+                url: 'https://example.com/app',
+                headers: new Headers({ 'content-type': 'text/html' }),
+                text: async () => '<html><body><div id="app"></div><script src="app.js"></script></body></html>'
+            })
+        });
+        const result = await fetcher('https://example.com/app');
+        expect(result.status).toBe('needs_headless');
+    });
+    it('returns needs_headless for weak content on a js-heavy shell page', async () => {
+        const fetcher = createHttpFetcher({
+            fetchImpl: vi.fn().mockResolvedValue({
+                ok: true,
+                url: 'https://www.airbnb.com/',
+                headers: new Headers({ 'content-type': 'text/html;charset=utf-8' }),
+                text: async () => '<html><head><title>Airbnb | Vacation rentals, cabins, beach houses, & more</title></head><body><div id="root"></div><noscript>Enable JavaScript</noscript><main><p>Become a host</p><p>It\'s easy to start hosting and earn extra income.</p></main></body></html>'
+            })
+        });
+        const result = await fetcher('https://www.airbnb.com/');
+        expect(result.status).toBe('needs_headless');
+        expect(result.metadata.method).toBe('http');
+    });
+    it('returns ok for a short but legitimate simple page', async () => {
+        const fetcher = createHttpFetcher({
+            fetchImpl: vi.fn().mockResolvedValue({
+                ok: true,
+                url: 'https://example.com/',
+                headers: new Headers({ 'content-type': 'text/html' }),
+                text: async () => '<html><head><title>Example Domain</title></head><body><main><p>This domain is for use in documentation examples without needing permission.</p><p>Avoid use in operations.</p><a href="https://iana.org">Learn more</a></main></body></html>'
+            })
+        });
+        const result = await fetcher('https://example.com/');
+        expect(result.status).toBe('ok');
+        expect(result.metadata.method).toBe('http');
+    });
+    it('falls back to simple extraction and returns ok when content is still readable', async () => {
+        const fetcher = createHttpFetcher({
+            fetchImpl: vi.fn().mockResolvedValue({
+                ok: true,
+                url: 'https://example.com/broken-css',
+                headers: new Headers({ 'content-type': 'text/html; charset=utf-8' }),
+                text: async () => `<html>
+            <head>
+              <title>Broken CSS Page</title>
+              <style>
+                .btn {
+                  color: red;
+                  &:hover {
+                    color: blue;
+                  }
+                }
+              </style>
+            </head>
+            <body>
+              <main>
+                <h1>Broken CSS Page</h1>
+                <p>This page should still produce useful readable text through the fallback path.</p>
+                <p>It contains enough content to count as a legitimate HTTP success.</p>
+              </main>
+            </body>
+          </html>`
+            })
+        });
+        const result = await fetcher('https://example.com/broken-css');
+        expect(result.status).toBe('ok');
+        expect(result.content?.title).toBe('Broken CSS Page');
+        expect(result.content?.text).toContain('useful readable text through the fallback path');
+    });
+    it('returns needs_headless instead of crashing when fallback content is still weak', async () => {
+        const fetcher = createHttpFetcher({
+            fetchImpl: vi.fn().mockResolvedValue({
+                ok: true,
+                url: 'https://example.com/broken-shell',
+                headers: new Headers({ 'content-type': 'text/html; charset=utf-8' }),
+                text: async () => `<html>
+            <head>
+              <title>Broken Shell</title>
+              <style>
+                .card {
+                  &:hover {
+                    opacity: 1;
+                  }
+                }
+              </style>
+            </head>
+            <body>
+              <div id="app"></div>
+              <noscript>Enable JavaScript</noscript>
+              <main><p>Hi</p></main>
+            </body>
+          </html>`
+            })
+        });
+        const result = await fetcher('https://example.com/broken-shell');
+        expect(result.status).toBe('needs_headless');
+        expect(result.error?.code).toBe('WEAK_EXTRACTION');
+    });
+    it('returns unsupported for binary content', async () => {
+        const fetcher = createHttpFetcher({
+            fetchImpl: vi.fn().mockResolvedValue({
+                ok: true,
+                url: 'https://example.com/file.pdf',
+                headers: new Headers({ 'content-type': 'application/pdf' }),
+                text: async () => ''
+            })
+        });
+        const result = await fetcher('https://example.com/file.pdf');
+        expect(result.status).toBe('unsupported');
+    });
+});

package/dist/tests/orchestration/research-orchestrator.test.d.ts

@@ -0,0 +1 @@
+export {};