newmark-agent 0.5.11 → 0.5.13

package/dist/server.js

@@ -56,6 +56,7 @@ const nativeBash_1 = require("./core/nativeBash");
 const installUpdate_1 = require("./core/installUpdate");
 const mobilePairing_1 = require("./core/mobilePairing");
 const workEventCoalescer_1 = require("./core/workEventCoalescer");
+const searchMcpPool_1 = require("./core/searchMcpPool");
 const PORT = 47890;
 let agent = null;
 let automation = null;
@@ -995,6 +996,40 @@ async function handleApi(req, res, body) {
                 });
                 return;
             }
+            case '/api/mobile/web-search': {
+                const input = JSON.parse(body || '{}');
+                const query = String(input.query || '').trim();
+                if (!query) {
+                    mobileJson(res, { ok: false, error: 'query is required' }, 400);
+                    return;
+                }
+                if (query.length > 2_000) {
+                    mobileJson(res, { ok: false, error: 'query is too long' }, 400);
+                    return;
+                }
+                const result = await agent.tools.webSearchDetailed(query);
+                mobileJson(res, result);
+                return;
+            }
+            case '/api/mobile/web-search-mcp': {
+                const input = JSON.parse(body || '{}');
+                const query = String(input.query || '').trim();
+                if (!query) {
+                    mobileJson(res, { ok: false, error: 'query is required' }, 400);
+                    return;
+                }
+                if (query.length > 2_000) {
+                    mobileJson(res, { ok: false, error: 'query is too long' }, 400);
+                    return;
+                }
+                const result = await agent.tools.webSearchMcpOnly(query);
+                mobileJson(res, result);
+                return;
+            }
+            case '/api/mobile/search-mcp-manifest': {
+                mobileJson(res, { version: 1, endpoints: (0, searchMcpPool_1.publicSearchMcpManifest)(appRoot) });
+                return;
+            }
             case '/api/mobile/state': {
                 const active = agent.getConversationSnapshot(agent.activeConversationId, { window: 200 });
                 // 完整对话信息：workRuns 用持久化记录透出（含被中断的构建，不依赖运行时内存）

package/dist/tools/index.d.ts

@@ -3,6 +3,7 @@ import { NewmarkToolDefinition, NewmarkToolResult } from '../core/compat';
 import { SshManager } from '../core/ssh';
 import { WorkspaceManager } from '../core/workspace';
 import { LocalOcrResult } from '../core/localOcr';
+import { SearchMcpAttempt } from '../core/searchMcpPool';
 export interface ToolExecutionContext {
     mode?: string;
     workspacePath?: string;
@@ -21,6 +22,14 @@ export interface ToolHostProfile {
     electronBrowser: boolean;
     windowsComputerUse: boolean;
 }
+export interface WebSearchResult {
+    invocationId: string;
+    checkedAt: string;
+    ok: boolean;
+    provider: string;
+    text: string;
+    attempts: SearchMcpAttempt[];
+}
 export declare class ToolExecutor {
     private config;
     private ssh?;
@@ -28,11 +37,17 @@ export declare class ToolExecutor {
     private root;
     private readonly localOcr;
     private readonly argumentValidators;
+    private readonly searchMcpPool;
     private hostProfile;
     constructor(root: string, config: ConfigManager, ssh?: SshManager | undefined, workspace?: WorkspaceManager | undefined);
-    webSearch(query: string): Promise<string>;
+    webSearch(query: string, signal?: AbortSignal): Promise<string>;
+    webSearchDetailed(query: string, signal?: AbortSignal): Promise<WebSearchResult>;
+    /** Search the configured MCP pool without entering any HTTP fallback. */
+    webSearchMcpOnly(query: string, signal?: AbortSignal): Promise<WebSearchResult>;
     /** OCR entry point for the runtime's final visual fallback. */
     finalVisualFallbackOcr(dataUrl: string, signal?: AbortSignal): Promise<LocalOcrResult>;
+    private readPdfFile;
+    private extractPdfText;
     setHostProfile(profile: ToolHostProfile): void;
     definitions(mode?: string): unknown[];
     canonicalDefinitions(mode?: string): NewmarkToolDefinition[];
@@ -70,6 +85,7 @@ export declare class ToolExecutor {
     private proxyEnvironment;
     private proxyExec;
     private wsearch;
+    private wsearchDetailed;
     private wfetch;
     private browserRun;
     private formatBrowserResult;

package/dist/tools/index.js

@@ -60,6 +60,7 @@ const toolArgumentValidator_1 = require("../core/toolArgumentValidator");
 const localOcr_1 = require("../core/localOcr");
 const visualTextFallback_1 = require("../core/visualTextFallback");
 const computerUseSession_1 = require("../core/computerUseSession");
+const searchMcpPool_1 = require("../core/searchMcpPool");
 function normalizeComputerUseAction(action) {
     return String(action || '').trim().toLowerCase();
 }
@@ -149,7 +150,7 @@ function decodePdfLiteral(input) {
         .replace(/\\t/g, '\t')
         .replace(/\\([0-7]{1,3})/g, (_match, octal) => String.fromCharCode(parseInt(octal, 8)));
 }
-function extractPdfTextLayer(buffer) {
+function extractPdfTextLayerLegacy(buffer) {
     const binary = buffer.toString('latin1');
     const chunks = [];
     for (const match of binary.matchAll(/\((?:\\.|[^\\)]){1,4000}\)\s*Tj/g)) {
@@ -171,6 +172,61 @@ function extractPdfTextLayer(buffer) {
     }
     return chunks.join(' ').replace(/\s+/g, ' ').trim().slice(0, 100_000);
 }
+async function extractPdfTextLayer(buffer, maxChars, signal) {
+    if (signal?.aborted)
+        throw abortReason(signal);
+    let loadingTask = null;
+    try {
+        const pdfjs = await import('pdfjs-dist/legacy/build/pdf.mjs');
+        loadingTask = pdfjs.getDocument({
+            data: new Uint8Array(buffer),
+            isEvalSupported: false,
+            useSystemFonts: true,
+            stopAtErrors: false,
+        });
+        const abortPromise = signal ? new Promise((_resolve, reject) => {
+            signal.addEventListener('abort', () => reject(abortReason(signal)), { once: true });
+        }) : null;
+        const document = await (abortPromise ? Promise.race([loadingTask.promise, abortPromise]) : loadingTask.promise);
+        const chunks = [];
+        let length = 0;
+        for (let pageNumber = 1; pageNumber <= document.numPages && length < maxChars; pageNumber += 1) {
+            if (signal?.aborted)
+                throw abortReason(signal);
+            const page = await document.getPage(pageNumber);
+            const content = await page.getTextContent({ disableNormalization: false });
+            const pageText = (Array.isArray(content.items) ? content.items : [])
+                .map((item) => `${String(item.str || '')}${item.hasEOL ? '\n' : ' '}`)
+                .join('')
+                .replace(/[ \t]+\n/g, '\n')
+                .replace(/[ \t]{2,}/g, ' ')
+                .trim();
+            if (pageText) {
+                const bounded = pageText.slice(0, Math.max(0, maxChars - length));
+                chunks.push(bounded);
+                length += bounded.length + 1;
+            }
+            page.cleanup();
+        }
+        return chunks.join('\n').trim().slice(0, maxChars);
+    }
+    catch (error) {
+        if (signal?.aborted)
+            throw abortReason(signal);
+        // Retain the bounded legacy decoder for minimal/malformed fixture PDFs and
+        // old documents whose streams pdf.js rejects. It never opens the browser.
+        const fallback = extractPdfTextLayerLegacy(buffer).slice(0, maxChars);
+        if (fallback)
+            return fallback;
+        return '';
+    }
+    finally {
+        try {
+            await loadingTask?.destroy();
+        }
+        catch { }
+    }
+}
 async function abortableToolDelay(durationMs, signal) {
     if (signal?.aborted)
         throw abortReason(signal);
@@ -219,6 +275,7 @@ class ToolExecutor {
     root;
     localOcr;
     argumentValidators = new toolArgumentValidator_1.ToolArgumentValidatorRegistry();
+    searchMcpPool;
     hostProfile = {
         kind: 'desktop',
         platform: process.platform,
@@ -231,14 +288,38 @@ class ToolExecutor {
         this.workspace = workspace;
         this.root = root;
         this.localOcr = new localOcr_1.LocalOcrEngine(root);
+        this.searchMcpPool = new searchMcpPool_1.SearchMcpPool(root);
     }
-    async webSearch(query) {
-        return this.wsearch(query);
+    async webSearch(query, signal) {
+        return (await this.webSearchDetailed(query, signal)).text;
+    }
+    async webSearchDetailed(query, signal) {
+        return this.wsearchDetailed(query, signal);
+    }
+    /** Search the configured MCP pool without entering any HTTP fallback. */
+    async webSearchMcpOnly(query, signal) {
+        const result = await this.searchMcpPool.search(query, signal);
+        return {
+            invocationId: result.invocationId,
+            checkedAt: result.checkedAt,
+            ok: result.ok,
+            provider: result.provider || '',
+            text: result.text || '',
+            attempts: result.attempts,
+        };
     }
     /** OCR entry point for the runtime's final visual fallback. */
     async finalVisualFallbackOcr(dataUrl, signal) {
         return await this.localOcr.recognizeDataUrl(dataUrl, signal, 'sparse-ui');
     }
+    async readPdfFile(pdfPath, signal) {
+        if (signal?.aborted)
+            throw abortReason(signal);
+        return await fs.promises.readFile(pdfPath, signal ? { signal } : undefined);
+    }
+    async extractPdfText(buffer, maxChars, signal) {
+        return await extractPdfTextLayer(buffer, maxChars, signal);
+    }
     setHostProfile(profile) {
         this.hostProfile = { ...profile };
     }
@@ -282,8 +363,9 @@ class ToolExecutor {
             t('browser_forward', 'Navigate the controlled browser forward.', {}, []),
             t('browser_reload', 'Reload the controlled browser.', {}, []),
             t('browser_cdp', 'Run a raw Chrome DevTools Protocol command against the controlled browser. Advanced use only.', { method: { type: 'string' }, params: { type: 'object' } }, ['method']),
-            t('browser_use', 'Native observe-then-act control for Newmark\'s built-in browser. Call observe first, then pass its page_generation, observation_id, and opaque ref to actions. Receipts are owner/runtime scoped; stale observations are rejected. This path does not require arbitrary page scripts or raw CDP.', {
+            t('browser_use', 'Native observe-then-act browser control. visible defaults to true and uses the right-sidebar built-in browser. Set visible=false to run on an independent host-owned background page that never connects to, displays, or renders the right-sidebar webview. Keep the same visible value throughout one observe/action sequence. Receipts are owner/runtime/surface scoped; stale observations are rejected.', {
                 action: { type: 'string', enum: browserUseActions },
+                visible: { type: 'boolean', description: 'Whether to bind to the visible right-sidebar browser. Defaults to true. false uses an independent background execution surface and does not create or touch the sidebar webview.' },
                 action_id: { type: 'string', description: 'Unique idempotency id for this action. Reusing it returns the original receipt without repeating the action.' },
                 page_generation: { type: 'number', description: 'Generation returned by the latest observe receipt.' },
                 observation_id: { type: 'string', description: 'Opaque observation capability returned by the latest observe receipt.' },
@@ -346,8 +428,9 @@ class ToolExecutor {
                     },
                 },
             }, ['action']),
-            t('image_inspect', 'Inspect a durable user-submitted image by stable attachment_id, or use image_index within the latest user message containing images. Use source_info first when dimensions are unknown, then crop with pixel coordinates. Derived crops are current-turn only and are never written to disk.', {
-                action: { type: 'string', enum: ['source_info', 'crop'] },
+            t('image_inspect', 'Inspect a durable user-submitted image by stable attachment_id or latest-message image_index, or send one active-workspace PNG/JPEG to the current validated vision model with action=inspect. Use source_info first when submitted-image dimensions are unknown, then crop with pixel coordinates. Workspace observations and derived crops are current-turn only; image bytes never enter durable tool history.', {
+                action: { type: 'string', enum: ['source_info', 'crop', 'inspect'] },
+                path: { type: 'string', description: 'For action=inspect, a workspace-relative PNG/JPEG path. Absolute paths are accepted only when they remain inside the active workspace.' },
                 attachment_id: { type: 'string', description: 'Stable user-image attachment id from the visible conversation. Prefer this when revisiting an older submitted image.' },
                 image_index: { type: 'number', description: '1-based image index in the latest user message containing submitted images. Defaults to 1.' },
                 x: { type: 'number', description: 'Crop left edge in source-image pixels.' },
@@ -366,10 +449,11 @@ class ToolExecutor {
                 path: { type: 'string', description: 'For source=image, a workspace PNG/JPEG/BMP path.' },
                 fallback_reason: { type: 'string', enum: ['vision_unavailable', 'vision_failed'] },
             }, ['source', 'fallback_reason']),
-            t('pdf_read', 'Read a PDF with enforced fallback order: embedded text layer first; if unreadable, render the requested page in Newmark Browser and send a screenshot to a validated vision model; use bundled Chinese/English OCR only when vision is unavailable, or later through ocr_read after vision failed. Designed for scanned PDFs, not layout/table reconstruction.', {
+            t('pdf_read', 'Read a PDF with enforced fallback order: embedded text layer first; if unreadable, render the requested page in Newmark Browser and send a screenshot to a validated vision model; use bundled Chinese/English OCR only when vision is unavailable, or later through ocr_read after vision failed. One cumulative timeout covers the entire PDF read, including file I/O, pdf.js parsing, and rendered-page observation. Designed for scanned PDFs, not layout/table reconstruction.', {
                 path: { type: 'string', description: 'Workspace PDF path.' },
                 page: { type: 'number', minimum: 1, maximum: 100, description: 'Page to render when no usable text layer exists. Defaults to 1.' },
                 max_chars: { type: 'number', minimum: 500, maximum: 100000 },
+                timeout_ms: { type: 'number', minimum: 1000, maximum: 120000, description: 'Bounded entire PDF read timeout. Defaults to 30000 ms. A timeout returns a recoverable tool result and does not abort the Agent run.' },
             }, ['path']),
             t('terminal_takeover', 'Take over a persistent owner-scoped PTY session that is independent from the one-shot bash tool. Actions: start creates/reuses a named PTY, write sends a command to the same session, read returns its output buffer, resize updates PTY geometry, detach releases the UI attachment without stopping the shell, stop interrupts it, list shows sessions. Use this when the user wants continuous terminal state such as cd/env/process context or interactive TTY programs.', {
                 action: { type: 'string', enum: ['start', 'write', 'read', 'resize', 'detach', 'stop', 'list'] },
@@ -517,6 +601,7 @@ class ToolExecutor {
                 copy.function.description = 'Plan read-only browser: observe, navigate, wait, extract only.';
                 copy.function.parameters.properties = {
                     action: { type: 'string', enum: [...toolPolicy_1.PLAN_BROWSER_USE_ACTIONS] },
+                    visible: copy.function.parameters.properties.visible,
                     action_id: copy.function.parameters.properties.action_id,
                     page_generation: copy.function.parameters.properties.page_generation,
                     observation_id: copy.function.parameters.properties.observation_id,
@@ -688,6 +773,7 @@ class ToolExecutor {
                     const scope = browserUseScope(context, wsPath);
                     const request = {
                         ...scope,
+                        visible: typeof args.visible === 'boolean' ? args.visible : true,
                         action: String(args.action || '').trim().toLowerCase(),
                         ...(g('action_id') ? { actionId: g('action_id') } : {}),
                         ...(args.page_generation !== undefined ? { pageGeneration: Number(args.page_generation) } : {}),
@@ -760,47 +846,79 @@ class ToolExecutor {
                     const pdfPath = resolve(g('path'));
                     if (path.extname(pdfPath).toLowerCase() !== '.pdf')
                         return '[pdf_read error] path must end in .pdf.';
-                    const stat = fs.statSync(pdfPath);
-                    if (!stat.isFile() || stat.size <= 0 || stat.size > 250 * 1024 * 1024) {
-                        return '[pdf_read error] PDF must be a regular file no larger than 250 MB.';
-                    }
                     const maxChars = Math.max(500, Math.min(100_000, Number(args.max_chars || 50_000)));
-                    const textLayer = extractPdfTextLayer(fs.readFileSync(pdfPath)).slice(0, maxChars);
-                    const readableCount = (textLayer.match(/[A-Za-z0-9\u3400-\u9fff]/g) || []).length;
-                    if (readableCount >= 20) {
+                    const page = Math.max(1, Math.min(100, Math.floor(Number(args.page || 1))));
+                    const timeoutMs = Math.max(1000, Math.min(120_000, Number(args.timeout_ms || 30_000)));
+                    const guard = abortGuard(context.signal, timeoutMs);
+                    let stage = 'file_stat';
+                    try {
+                        const guardedContext = { ...context, signal: guard.signal };
+                        const stat = await fs.promises.stat(pdfPath);
+                        if (!stat.isFile() || stat.size <= 0 || stat.size > 250 * 1024 * 1024) {
+                            return '[pdf_read error] PDF must be a regular file no larger than 250 MB.';
+                        }
+                        stage = 'file_read';
+                        const bytes = await this.readPdfFile(pdfPath, guard.signal);
+                        stage = 'text_parse';
+                        const textLayer = await this.extractPdfText(bytes, maxChars, guard.signal);
+                        const readableCount = (textLayer.match(/[A-Za-z0-9\u3400-\u9fff]/g) || []).length;
+                        if (readableCount >= 20) {
+                            return JSON.stringify({
+                                ok: true,
+                                source: 'pdf_text_layer',
+                                recognition_order: 'text>vision>local_ocr',
+                                text: textLayer,
+                                truncated: textLayer.length >= maxChars,
+                            }, null, 2);
+                        }
+                        stage = 'rendered_page_observation';
+                        const url = `${(0, url_1.pathToFileURL)(pdfPath).toString()}#page=${page}&zoom=page-fit`;
+                        const opened = await this.browserRun({ action: 'open', url }, guard.signal, guardedContext, wsPath);
+                        if (!opened.includes('[browser:open] OK')) {
+                            return JSON.stringify({ ok: false, source: 'pdf_render', code: 'pdf_open_failed', error: opened || 'Unable to open PDF.' }, null, 2);
+                        }
+                        await abortableToolDelay(900, guard.signal);
+                        const observed = await this.execute('browser_use', JSON.stringify({
+                            action: 'observe',
+                            action_id: `pdf-read-${crypto.randomUUID()}`,
+                            max_chars: maxChars,
+                            max_refs: 80,
+                        }), wsPath, guardedContext);
+                        if (guard.signal.aborted)
+                            throw abortReason(guard.signal);
+                        let parsed = observed;
+                        try {
+                            parsed = JSON.parse(observed);
+                        }
+                        catch { }
                         return JSON.stringify({
                             ok: true,
-                            source: 'pdf_text_layer',
+                            source: 'pdf_rendered_page',
+                            page,
                             recognition_order: 'text>vision>local_ocr',
-                            text: textLayer,
-                            truncated: textLayer.length >= maxChars,
+                            result: parsed,
                         }, null, 2);
                     }
-                    const page = Math.max(1, Math.min(100, Math.floor(Number(args.page || 1))));
-                    const url = `${(0, url_1.pathToFileURL)(pdfPath).toString()}#page=${page}&zoom=page-fit`;
-                    const opened = await this.browserRun({ action: 'open', url }, context.signal, context, wsPath);
-                    if (!opened.includes('[browser:open] OK')) {
-                        return JSON.stringify({ ok: false, source: 'pdf_render', error: opened || 'Unable to open PDF.' }, null, 2);
+                    catch (error) {
+                        if (context.signal?.aborted)
+                            throw abortReason(context.signal);
+                        if (guard.signal.aborted) {
+                            return JSON.stringify({
+                                ok: false,
+                                source: stage === 'rendered_page_observation' ? 'pdf_rendered_page' : 'pdf_read',
+                                code: 'pdf_read_timeout',
+                                stage,
+                                page,
+                                timeout_ms: timeoutMs,
+                                recoverable: true,
+                                error: `PDF read timed out during ${stage} after ${timeoutMs} ms. The Agent run can continue or retry with a larger timeout_ms.`,
+                            }, null, 2);
+                        }
+                        throw error;
                     }
-                    await abortableToolDelay(900, context.signal);
-                    const observed = await this.execute('browser_use', JSON.stringify({
-                        action: 'observe',
-                        action_id: `pdf-read-${crypto.randomUUID()}`,
-                        max_chars: maxChars,
-                        max_refs: 80,
-                    }), wsPath, context);
-                    let parsed = observed;
-                    try {
-                        parsed = JSON.parse(observed);
+                    finally {
+                        guard.dispose();
                     }
-                    catch { }
-                    return JSON.stringify({
-                        ok: true,
-                        source: 'pdf_rendered_page',
-                        page,
-                        recognition_order: 'text>vision>local_ocr',
-                        result: parsed,
-                    }, null, 2);
                 }
                 case 'screen_capture': {
                     const target = g('target').toLowerCase() === 'application' ? 'application' : 'desktop';
@@ -1357,6 +1475,9 @@ class ToolExecutor {
         }
     }
     async wsearch(query, signal) {
+        return (await this.wsearchDetailed(query, signal)).text;
+    }
+    async wsearchDetailed(query, signal) {
         const clean = (s) => s
             .replace(/<[^>]+>/g, ' ')
             .replace(/&amp;/g, '&')
@@ -1367,34 +1488,23 @@ class ToolExecutor {
             .replace(/\s+/g, ' ')
             .trim();
         const errors = [];
+        let mcp = { invocationId: '', checkedAt: '', ok: false, attempts: [] };
         try {
-            const url = `https://html.duckduckgo.com/html/?q=${encodeURIComponent(query)}`;
-            const guard = abortGuard(signal, 15000);
-            let html = '';
-            try {
-                const resp = await this.proxyFetch(url, {
-                    headers: { 'User-Agent': 'NewmarkAgent/1.0' },
-                    signal: guard.signal,
-                });
-                html = await resp.text();
+            mcp = await this.webSearchMcpOnly(query, signal);
+            if (mcp.ok && mcp.text) {
+                return { invocationId: mcp.invocationId, checkedAt: mcp.checkedAt, ok: true, provider: mcp.provider || 'MCP search', text: mcp.text, attempts: mcp.attempts };
             }
-            finally {
-                guard.dispose();
-            }
-            const re = /<a[^>]+class="result__a"[^>]+href="([^"]+)"[^>]*>(.*?)<\/a>[\s\S]*?class="result__snippet">(.*?)<\/a>/g;
-            const results = [];
-            let m;
-            while ((m = re.exec(html)) !== null && results.length < 8) {
-                results.push(`${clean(m[2])}\n${clean(m[1])}\n${clean(m[3])}`);
+            for (const attempt of mcp.attempts) {
+                if (attempt.status === 'error')
+                    errors.push(`${attempt.name}: ${attempt.error || 'failed'}`);
+                else if (attempt.status === 'empty')
+                    errors.push(`${attempt.name}: no results`);
             }
-            if (results.length > 0)
-                return results.join('\n\n');
-            errors.push('DuckDuckGo returned no parseable results');
         }
-        catch (e) {
+        catch (error) {
             if (signal?.aborted)
                 throw abortReason(signal);
-            errors.push(`DuckDuckGo: ${e instanceof Error ? e.message : String(e)}`);
+            errors.push(`Search MCP pool: ${error instanceof Error ? error.message : String(error)}`);
         }
         try {
             const url = `https://www.bing.com/search?q=${encodeURIComponent(query)}`;
@@ -1422,7 +1532,7 @@ class ToolExecutor {
                 results.push(`${clean(title[2])}\n${clean(title[1])}\n${snippet ? clean(snippet[1]) : ''}`.trim());
             }
             if (results.length > 0)
-                return results.join('\n\n');
+                return { invocationId: mcp.invocationId, checkedAt: mcp.checkedAt, ok: true, provider: 'Bing HTTP', text: results.join('\n\n'), attempts: mcp.attempts };
             errors.push('Bing returned no parseable results');
         }
         catch (e) {
@@ -1430,7 +1540,36 @@ class ToolExecutor {
                 throw abortReason(signal);
             errors.push(`Bing: ${e instanceof Error ? e.message : String(e)}`);
         }
-        return `[web_search] No results. ${errors.join('; ')}`;
+        try {
+            const url = `https://html.duckduckgo.com/html/?q=${encodeURIComponent(query)}`;
+            const guard = abortGuard(signal, 15000);
+            let html = '';
+            try {
+                const resp = await this.proxyFetch(url, {
+                    headers: { 'User-Agent': 'NewmarkAgent/1.0' },
+                    signal: guard.signal,
+                });
+                html = await resp.text();
+            }
+            finally {
+                guard.dispose();
+            }
+            const re = /<a[^>]+class="result__a"[^>]+href="([^"]+)"[^>]*>(.*?)<\/a>[\s\S]*?class="result__snippet">(.*?)<\/a>/g;
+            const results = [];
+            let match;
+            while ((match = re.exec(html)) !== null && results.length < 8) {
+                results.push(`${clean(match[2])}\n${clean(match[1])}\n${clean(match[3])}`);
+            }
+            if (results.length > 0)
+                return { invocationId: mcp.invocationId, checkedAt: mcp.checkedAt, ok: true, provider: 'DuckDuckGo HTTP', text: results.join('\n\n'), attempts: mcp.attempts };
+            errors.push('DuckDuckGo returned no parseable results');
+        }
+        catch (e) {
+            if (signal?.aborted)
+                throw abortReason(signal);
+            errors.push(`DuckDuckGo: ${e instanceof Error ? e.message : String(e)}`);
+        }
+        return { invocationId: mcp.invocationId, checkedAt: mcp.checkedAt, ok: false, provider: '', text: `[web_search] No results. ${errors.join('; ')}`, attempts: mcp.attempts };
     }
     async wfetch(url, signal) {
         try {

package/dist/tui/src/data.js

@@ -20,7 +20,7 @@ const navigation = [
 const workspace = {
   id: "workspace-newmark-agent-demo",
   name: "Newmark Agent",
-  path: "C:\\Users\\12252\\Desktop\\Files\\Code\\Newmark Agent",
+  path: "C:\\Users\\DemoUser\\Projects\\Newmark Agent",
   isInternal: false,
   hostBinding: "demo-host",
   icon: "[W]",
@@ -40,7 +40,7 @@ const workspaces = [
   {
     id: "workspace-condensed-lab-demo",
     name: "Condensed Lab",
-    path: "C:\\Users\\12252\\Desktop\\Files\\Condensed Lab",
+    path: "C:\\Users\\DemoUser\\Projects\\Condensed Lab",
     isInternal: false,
     hostBinding: "demo-host",
     icon: "[W]",