noteconnection 1.7.0 → 1.8.0

package/dist/src/notemd/operations/types.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/src/notemd/providerDiagnostics.js

@@ -0,0 +1,220 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.MAX_PROVIDER_DIAGNOSTIC_STABILITY_RUNS = exports.DEFAULT_PROVIDER_DIAGNOSTIC_STABILITY_RUNS = exports.DEFAULT_PROVIDER_DIAGNOSTIC_CALL_MODE = exports.DEFAULT_PROVIDER_DIAGNOSTIC_TIMEOUT_MS = void 0;
+exports.getProviderDiagnosticCallModeOptions = getProviderDiagnosticCallModeOptions;
+exports.buildDefaultProviderDiagnosticPayload = buildDefaultProviderDiagnosticPayload;
+exports.buildProviderDiagnosticFileName = buildProviderDiagnosticFileName;
+exports.buildProviderDiagnosticOperationInput = buildProviderDiagnosticOperationInput;
+exports.runProviderDiagnosticProbe = runProviderDiagnosticProbe;
+exports.runProviderDiagnosticStabilityProbe = runProviderDiagnosticStabilityProbe;
+exports.DEFAULT_PROVIDER_DIAGNOSTIC_TIMEOUT_MS = 10 * 60 * 1000;
+const MAX_RESPONSE_PREVIEW_CHARS = 8000;
+exports.DEFAULT_PROVIDER_DIAGNOSTIC_CALL_MODE = 'runtime-stable';
+exports.DEFAULT_PROVIDER_DIAGNOSTIC_STABILITY_RUNS = 3;
+exports.MAX_PROVIDER_DIAGNOSTIC_STABILITY_RUNS = 10;
+const PROVIDER_DIAGNOSTIC_CALL_MODE_OPTIONS = [
+    {
+        value: 'runtime-stable',
+        label: 'Runtime stable (auto)',
+        description: 'Use the stable runtime path (stream -> non-stream -> fallback).',
+        openaiCompatibleOnly: false
+    },
+    {
+        value: 'runtime-requesturl-first',
+        label: 'Runtime requestUrl-first',
+        description: 'Use requestUrl-first runtime behavior before streamed fallback parsing.',
+        openaiCompatibleOnly: false
+    }
+];
+function redactApiKey(apiKey) {
+    if (!apiKey)
+        return '(empty)';
+    if (apiKey.length <= 6)
+        return '[REDACTED]';
+    return `${apiKey.slice(0, 3)}...${apiKey.slice(-3)} (redacted)`;
+}
+function normalizeMultiline(input) {
+    return input.replace(/\r\n/g, '\n');
+}
+function clipPreview(input, maxChars = MAX_RESPONSE_PREVIEW_CHARS) {
+    if (input.length <= maxChars)
+        return input;
+    return `${input.slice(0, maxChars)}\n\n...[${input.length - maxChars} chars omitted]`;
+}
+function normalizeStabilityRuns(input) {
+    const numeric = Number.isFinite(input) ? Math.floor(input) : exports.DEFAULT_PROVIDER_DIAGNOSTIC_STABILITY_RUNS;
+    if (numeric < 1)
+        return 1;
+    return Math.min(numeric, exports.MAX_PROVIDER_DIAGNOSTIC_STABILITY_RUNS);
+}
+function getProviderDiagnosticCallModeOptions(_provider) {
+    return PROVIDER_DIAGNOSTIC_CALL_MODE_OPTIONS.map(option => ({ ...option }));
+}
+function buildDefaultProviderDiagnosticPayload(providerName) {
+    const prompt = 'You are a diagnostic assistant. Return plain markdown text only. Do not use code fences.';
+    const contentBlock = 'Please produce a structured diagnostic response with: summary, numbered findings, risk notes, and a final checklist. Expand each section with details.';
+    const repeated = Array.from({ length: 10 }, (_, idx) => `Input block ${idx + 1}: ${contentBlock}`).join('\n\n');
+    return { prompt, content: `Provider diagnostic target: ${providerName}\n\n${repeated}` };
+}
+function buildProviderDiagnosticFileName(providerName, now) {
+    const safeProviderName = providerName
+        .replace(/[^a-zA-Z0-9_-]+/g, '_')
+        .replace(/_+/g, '_')
+        .replace(/^_+|_+$/g, '') || 'provider';
+    const timestamp = now.toISOString().replace(/[:.]/g, '-');
+    return `Notemd_Provider_Diagnostic_${safeProviderName}_${timestamp}.txt`;
+}
+function buildProviderDiagnosticOperationInput(provider, settings) {
+    return {
+        providerName: provider.name,
+        model: provider.model,
+        callMode: settings.developerDiagnosticCallMode || exports.DEFAULT_PROVIDER_DIAGNOSTIC_CALL_MODE,
+        timeoutMs: settings.developerDiagnosticTimeoutMs ?? exports.DEFAULT_PROVIDER_DIAGNOSTIC_TIMEOUT_MS,
+        stabilityRuns: settings.developerDiagnosticStabilityRuns ?? exports.DEFAULT_PROVIDER_DIAGNOSTIC_STABILITY_RUNS
+    };
+}
+function createInMemoryProgressReporter(logs) {
+    let cancelled = false;
+    const reporter = {
+        report(_event) { },
+        isCancelled() { return cancelled; }
+    };
+    reporter.log = (message) => { logs.push(`[${new Date().toISOString()}] ${message}`); };
+    return reporter;
+}
+function buildProviderDiagnosticReport(params) {
+    const { provider, settings, startedAt, timeoutMs, callMode, requestedCallMode, success, elapsedMs, logs, responseText, errorMessage, debugInfo } = params;
+    const sections = [
+        'Notemd Provider Diagnostic Report',
+        `Generated At: ${startedAt.toISOString()}`,
+        '',
+        '=== Provider Context ===',
+        `Provider: ${provider.name}`,
+        `Base URL: ${provider.baseUrl}`,
+        `Model: ${provider.model}`,
+        `Temperature: ${provider.temperature}`,
+        `API Key: ${redactApiKey(provider.apiKey)}`,
+        '',
+        '=== Runtime Settings ===',
+        `Stable API Calls: ${settings.enableStableApiCall ? 'enabled' : 'disabled'}`,
+        `Max Retries: ${settings.maxRetries}`,
+        `Requested Call Mode: ${requestedCallMode}`,
+        `Effective Call Mode: ${callMode}`,
+        `Timeout: ${timeoutMs}ms`,
+        '',
+        '=== Result ===',
+        `Result: ${success ? 'SUCCESS' : 'FAILED'}`,
+        `Elapsed: ${elapsedMs}ms`
+    ];
+    if (errorMessage)
+        sections.push(`Error: ${errorMessage}`);
+    if (debugInfo)
+        sections.push('', '=== Debug Details ===', normalizeMultiline(debugInfo));
+    if (responseText && responseText.trim())
+        sections.push('', '=== Response Preview ===', clipPreview(normalizeMultiline(responseText)));
+    sections.push('', '=== Runtime Logs ===');
+    sections.push(logs.length > 0 ? logs.join('\n') : '(no logs captured)');
+    return sections.join('\n');
+}
+async function runProviderDiagnosticProbe(provider, settings, llmCallImpl, options = {}) {
+    const payload = buildDefaultProviderDiagnosticPayload(provider.name);
+    const timeoutMs = options.timeoutMs ?? exports.DEFAULT_PROVIDER_DIAGNOSTIC_TIMEOUT_MS;
+    const requestedCallMode = options.callMode ?? exports.DEFAULT_PROVIDER_DIAGNOSTIC_CALL_MODE;
+    const callMode = requestedCallMode;
+    const runtimeStartedAtMs = Date.now();
+    const startedAt = options.now ?? new Date(runtimeStartedAtMs);
+    const logs = [];
+    const reporter = createInMemoryProgressReporter(logs);
+    reporter.log(`Developer diagnostic started for ${provider.name}.`);
+    reporter.log(`Using model '${provider.model}' at '${provider.baseUrl}'.`);
+    reporter.log(`Effective call mode: ${callMode}.`);
+    reporter.log(`Timeout configured to ${timeoutMs}ms.`);
+    const controller = new AbortController();
+    let timeoutHandle = null;
+    let success = false;
+    let responseText;
+    let errorMessage;
+    let debugInfo;
+    try {
+        timeoutHandle = setTimeout(() => {
+            reporter.log(`Diagnostic timeout reached (${timeoutMs}ms). Aborting request.`);
+            controller.abort();
+        }, timeoutMs);
+        responseText = await llmCallImpl(provider, payload.prompt, payload.content, { ...settings, enableApiErrorDebugMode: true, enableStableApiCall: true }, controller.signal);
+        success = true;
+        reporter.log(`Diagnostic completed successfully. Response length: ${responseText.length} chars.`);
+    }
+    catch (error) {
+        errorMessage = error instanceof Error ? error.message : String(error);
+        debugInfo = error instanceof Error ? error.stack : undefined;
+        reporter.log(`Diagnostic failed: ${errorMessage}`);
+        if (debugInfo)
+            reporter.log(`Diagnostic debug details:\n${debugInfo}`);
+    }
+    finally {
+        if (timeoutHandle)
+            clearTimeout(timeoutHandle);
+    }
+    const elapsedMs = Date.now() - runtimeStartedAtMs;
+    const report = buildProviderDiagnosticReport({
+        provider, settings, startedAt, timeoutMs, callMode, requestedCallMode,
+        success, elapsedMs, logs, responseText, errorMessage, debugInfo
+    });
+    return { success, elapsedMs, callMode, requestedCallMode, responseText, errorMessage, debugInfo, logs, report };
+}
+function buildProviderDiagnosticStabilityReport(params) {
+    const { provider, requestedCallMode, callMode, runs, successCount, failureCount, totalElapsedMs, runResults } = params;
+    const lines = [
+        'Notemd Provider Diagnostic Stability Report',
+        `Generated At: ${new Date().toISOString()}`,
+        '',
+        '=== Provider Context ===',
+        `Provider: ${provider.name}`,
+        `Base URL: ${provider.baseUrl}`,
+        `Model: ${provider.model}`,
+        `Requested Call Mode: ${requestedCallMode}`,
+        `Effective Call Mode: ${callMode}`,
+        '',
+        '=== Summary ===',
+        `Runs: ${runs}`,
+        `Success: ${successCount}`,
+        `Failed: ${failureCount}`,
+        `Total Elapsed: ${totalElapsedMs}ms`,
+        `Average Elapsed: ${runs > 0 ? Math.round(totalElapsedMs / runs) : 0}ms`,
+        ''
+    ];
+    runResults.forEach((run, index) => {
+        lines.push(`=== Run ${index + 1} ===`);
+        lines.push(`Result: ${run.success ? 'SUCCESS' : 'FAILED'}`);
+        lines.push(`Elapsed: ${run.elapsedMs}ms`);
+        if (run.errorMessage)
+            lines.push(`Error: ${run.errorMessage}`);
+        if (run.debugInfo) {
+            lines.push('Debug:');
+            lines.push(normalizeMultiline(run.debugInfo));
+        }
+        lines.push('');
+    });
+    return lines.join('\n');
+}
+async function runProviderDiagnosticStabilityProbe(provider, settings, llmCallImpl, options = {}) {
+    const runs = normalizeStabilityRuns(options.runs);
+    const requestedCallMode = options.callMode ?? exports.DEFAULT_PROVIDER_DIAGNOSTIC_CALL_MODE;
+    const runResults = [];
+    const startedAtMs = Date.now();
+    for (let runIndex = 0; runIndex < runs; runIndex += 1) {
+        const runResult = await runProviderDiagnosticProbe(provider, settings, llmCallImpl, {
+            ...options,
+            callMode: requestedCallMode
+        });
+        runResults.push(runResult);
+    }
+    const totalElapsedMs = Date.now() - startedAtMs;
+    const successCount = runResults.filter(run => run.success).length;
+    const failureCount = runResults.length - successCount;
+    const report = buildProviderDiagnosticStabilityReport({
+        provider, requestedCallMode, callMode: requestedCallMode,
+        runs, successCount, failureCount, totalElapsedMs, runResults
+    });
+    return { runs, callMode: requestedCallMode, requestedCallMode, successCount, failureCount, totalElapsedMs, runResults, report };
+}

package/dist/src/notemd/providerProfiles.js

@@ -0,0 +1,42 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.buildProviderProfileExport = buildProviderProfileExport;
+exports.parseProviderProfileImport = parseProviderProfileImport;
+function buildProviderProfileExport(providers, now = new Date()) {
+    return {
+        providers,
+        exportedAt: now.toISOString(),
+        formatVersion: 1
+    };
+}
+function parseProviderProfileImport(jsonData, existingProviders) {
+    const parsed = JSON.parse(jsonData);
+    const importedProviders = Array.isArray(parsed)
+        ? parsed
+        : Array.isArray(parsed.providers)
+            ? parsed.providers
+            : null;
+    if (!importedProviders) {
+        throw new Error('Imported file does not contain a valid provider array.');
+    }
+    const existingProvidersMap = new Map(existingProviders.map(provider => [provider.name, provider]));
+    let updatedCount = 0;
+    let newCount = 0;
+    importedProviders.forEach(importedProvider => {
+        if (importedProvider && typeof importedProvider.name === 'string') {
+            if (existingProvidersMap.has(importedProvider.name)) {
+                existingProvidersMap.set(importedProvider.name, importedProvider);
+                updatedCount += 1;
+            }
+            else {
+                existingProvidersMap.set(importedProvider.name, importedProvider);
+                newCount += 1;
+            }
+        }
+    });
+    return {
+        importedProviders: Array.from(existingProvidersMap.values()),
+        newCount,
+        updatedCount
+    };
+}

package/dist/src/notemd/providerTemplates.js

@@ -0,0 +1,231 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.NOTEMD_PROVIDER_TEMPLATES = void 0;
+exports.getNotemdProviderTemplate = getNotemdProviderTemplate;
+exports.applyProviderTemplateToSettings = applyProviderTemplateToSettings;
+exports.mergeProviderTemplatesIntoNotemdSection = mergeProviderTemplatesIntoNotemdSection;
+const LlmProviderDefinitions_1 = require("./LlmProviderDefinitions");
+const PROVIDER_TEMPLATE_SEEDS = [
+    {
+        id: 'deepseek-official',
+        providerName: 'DeepSeek',
+        label: 'DeepSeek Official',
+        recommendedFor: 'Direct hosted DeepSeek reasoning/chat models.',
+        apiKeyHint: 'Paste a DeepSeek API key.',
+        hostHint: 'Uses the official DeepSeek OpenAI-compatible endpoint.',
+        inspiredBy: ['Cherry Studio', 'DeepTutor'],
+        notes: [
+            'Keep the /v1 suffix for the official endpoint.',
+            'Reasoning-capable models may prefer lower temperature values.',
+        ],
+    },
+    {
+        id: 'openai-official',
+        providerName: 'OpenAI',
+        label: 'OpenAI Official',
+        recommendedFor: 'Direct OpenAI hosted GPT models.',
+        apiKeyHint: 'Paste an OpenAI API key.',
+        hostHint: 'Matches DeepTutor style host guidance: base URL stays at /v1.',
+        inspiredBy: ['Cherry Studio', 'DeepTutor'],
+        notes: [
+            'Use a direct API key, not a session token.',
+            'This preset is the cleanest baseline for hosted OpenAI models.',
+        ],
+    },
+    {
+        id: 'anthropic-official',
+        providerName: 'Anthropic',
+        label: 'Anthropic Official',
+        recommendedFor: 'Claude models over the native Anthropic API.',
+        apiKeyHint: 'Paste an Anthropic API key.',
+        hostHint: 'Anthropic does not use the OpenAI-compatible /v1 shape.',
+        inspiredBy: ['Cherry Studio'],
+        notes: [
+            'The base URL should usually remain https://api.anthropic.com.',
+            'Claude deployments do not need an OpenAI-compatible relay.',
+        ],
+    },
+    {
+        id: 'gemini-official',
+        providerName: 'Google',
+        label: 'Gemini Official',
+        recommendedFor: 'Google Gemini API over the official hosted endpoint.',
+        apiKeyHint: 'Paste a Google AI Studio / Gemini API key.',
+        hostHint: 'Uses the official Gemini REST endpoint, not an OpenAI relay.',
+        inspiredBy: ['Cherry Studio', 'DeepTutor'],
+        notes: [
+            'This preset is for direct Gemini API usage.',
+            'If you use an OpenAI-compatible Gemini relay, prefer OpenAI Compatible instead.',
+        ],
+    },
+    {
+        id: 'openrouter-gateway',
+        providerName: 'OpenRouter',
+        label: 'OpenRouter Gateway',
+        recommendedFor: 'Unified routing across many hosted model families.',
+        apiKeyHint: 'Paste an OpenRouter API key.',
+        hostHint: 'Gateway style endpoint inspired by Cherry Studio provider routing.',
+        inspiredBy: ['Cherry Studio'],
+        notes: [
+            'Model ids usually include upstream vendor prefixes.',
+            'Good default when you want one key for many providers.',
+        ],
+    },
+    {
+        id: 'lmstudio-local',
+        providerName: 'LMStudio',
+        label: 'LM Studio Local',
+        recommendedFor: 'Desktop local models exposed over an OpenAI-compatible server.',
+        apiKeyHint: 'Usually no API key is required.',
+        hostHint: 'DeepTutor-style local host guidance: prefer localhost on desktop, not inside containers.',
+        inspiredBy: ['Cherry Studio', 'DeepTutor'],
+        notes: [
+            'Keep the local server running before testing the connection.',
+            'If this app is containerized in the future, localhost must be replaced with a host bridge address.',
+        ],
+    },
+    {
+        id: 'ollama-local',
+        providerName: 'Ollama',
+        label: 'Ollama Local',
+        recommendedFor: 'Local Ollama chat models.',
+        apiKeyHint: 'No API key is required for a standard local Ollama instance.',
+        hostHint: "Uses Ollama's local HTTP API.",
+        inspiredBy: ['Cherry Studio', 'DeepTutor'],
+        notes: [
+            'The model name must match an installed Ollama model.',
+            'Keep the default host only for local desktop usage.',
+        ],
+    },
+    {
+        id: 'azure-openai',
+        providerName: 'Azure OpenAI',
+        label: 'Azure OpenAI',
+        recommendedFor: 'Azure OpenAI deployments that require deployment-specific base URLs.',
+        apiKeyHint: 'Paste an Azure OpenAI key.',
+        hostHint: 'Unlike standard OpenAI, Azure needs an explicit deployment URL and API version.',
+        inspiredBy: ['Cherry Studio', 'DeepTutor'],
+        notes: [
+            'Fill in the full Azure resource endpoint plus deployment path.',
+            'The API version field matters here and should not stay blank.',
+        ],
+    },
+    {
+        id: 'openai-compatible-custom',
+        providerName: 'OpenAI Compatible',
+        label: 'Custom OpenAI-Compatible',
+        recommendedFor: 'Self-hosted gateways, enterprise relays, and custom-compatible endpoints.',
+        apiKeyHint: 'Paste a key only if your relay requires one.',
+        hostHint: 'Use this when the endpoint follows OpenAI-compatible chat semantics.',
+        inspiredBy: ['Cherry Studio'],
+        notes: [
+            'Best fallback preset when your provider is not in the built-in catalog.',
+            'Check that the base URL already includes the /v1 segment if required by your relay.',
+        ],
+    },
+];
+function buildTemplateFromSeed(seed) {
+    const fallback = (0, LlmProviderDefinitions_1.createDefaultProviders)().find((provider) => provider.name === seed.providerName);
+    const definition = (0, LlmProviderDefinitions_1.getProviderDefinition)(seed.providerName);
+    const defaultConfig = fallback || {
+        name: seed.providerName,
+        apiKey: '',
+        baseUrl: '',
+        model: '',
+        temperature: 0.5,
+        apiVersion: '',
+        enabled: true,
+    };
+    return {
+        id: seed.id,
+        label: seed.label,
+        providerName: seed.providerName,
+        category: definition.category,
+        transport: definition.transport,
+        apiKeyMode: definition.apiKeyMode,
+        baseUrl: defaultConfig.baseUrl,
+        model: defaultConfig.model,
+        apiVersion: String(defaultConfig.apiVersion || ''),
+        temperature: Number.isFinite(Number(defaultConfig.temperature))
+            ? Number(defaultConfig.temperature)
+            : 0.5,
+        recommendedFor: seed.recommendedFor,
+        apiKeyHint: seed.apiKeyHint,
+        hostHint: seed.hostHint,
+        inspiredBy: seed.inspiredBy.slice(),
+        notes: seed.notes.slice(),
+    };
+}
+exports.NOTEMD_PROVIDER_TEMPLATES = PROVIDER_TEMPLATE_SEEDS.map(buildTemplateFromSeed);
+function getNotemdProviderTemplate(templateId) {
+    const normalizedId = String(templateId || '').trim();
+    return exports.NOTEMD_PROVIDER_TEMPLATES.find((template) => template.id === normalizedId) || null;
+}
+function applyProviderTemplateToSettings(settings, templateId) {
+    const template = getNotemdProviderTemplate(templateId);
+    if (!template) {
+        throw new Error(`Unknown provider template: ${templateId}`);
+    }
+    const next = JSON.parse(JSON.stringify(settings));
+    next.activeProvider = template.providerName;
+    let matched = false;
+    next.providers = next.providers.map((provider) => {
+        if (provider.name !== template.providerName) {
+            return provider;
+        }
+        matched = true;
+        return {
+            ...provider,
+            baseUrl: template.baseUrl,
+            model: template.model,
+            apiVersion: template.apiVersion,
+            temperature: template.temperature,
+            enabled: true,
+        };
+    });
+    if (!matched) {
+        const fallback = (0, LlmProviderDefinitions_1.createDefaultProviders)().find((provider) => provider.name === template.providerName);
+        if (fallback) {
+            next.providers.push({
+                ...fallback,
+                baseUrl: template.baseUrl,
+                model: template.model,
+                apiVersion: template.apiVersion,
+                temperature: template.temperature,
+                enabled: true,
+            });
+        }
+    }
+    return next;
+}
+function mergeProviderTemplatesIntoNotemdSection(notemdSectionLike) {
+    const nextNotemdSection = { ...(notemdSectionLike || {}) };
+    const existingTemplates = (nextNotemdSection.provider_templates &&
+        typeof nextNotemdSection.provider_templates === 'object' &&
+        !Array.isArray(nextNotemdSection.provider_templates))
+        ? { ...nextNotemdSection.provider_templates }
+        : {};
+    exports.NOTEMD_PROVIDER_TEMPLATES.forEach((template) => {
+        if (existingTemplates[template.id] && typeof existingTemplates[template.id] === 'object') {
+            return;
+        }
+        existingTemplates[template.id] = {
+            label: template.label,
+            provider_name: template.providerName,
+            category: template.category,
+            transport: template.transport,
+            api_key_mode: template.apiKeyMode,
+            base_url: template.baseUrl,
+            model: template.model,
+            api_version: template.apiVersion,
+            temperature: template.temperature,
+            recommended_for: template.recommendedFor,
+            api_key_hint: template.apiKeyHint,
+            host_hint: template.hostHint,
+            inspired_by: template.inspiredBy.slice(),
+            notes: template.notes.slice(),
+        };
+    });
+    nextNotemdSection.provider_templates = existingTemplates;
+    return nextNotemdSection;
+}

package/dist/src/notemd/search/DuckDuckGoProvider.js

@@ -0,0 +1,39 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DuckDuckGoProvider = void 0;
+class DuckDuckGoProvider {
+    constructor() {
+        this.name = 'duckduckgo';
+    }
+    async search(query, _apiKey, timeout = 10000) {
+        const encoded = encodeURIComponent(query.query);
+        const url = `https://api.duckduckgo.com/?q=${encoded}&format=json&no_html=1&skip_disambig=1`;
+        const maxResults = query.maxResults ?? 5;
+        const controller = new AbortController();
+        const timer = setTimeout(() => controller.abort(), timeout);
+        try {
+            const response = await fetch(url, { signal: controller.signal });
+            if (!response.ok)
+                return [];
+            const data = (await response.json());
+            const results = [];
+            if (data.AbstractText && data.AbstractURL) {
+                results.push({ title: data.AbstractText.slice(0, 100), url: data.AbstractURL, content: data.AbstractText });
+            }
+            const topics = data.RelatedTopics ?? [];
+            for (const topic of topics.slice(0, maxResults)) {
+                if (topic.Text && topic.FirstURL) {
+                    results.push({ title: topic.Text.slice(0, 100), url: topic.FirstURL, content: topic.Text });
+                }
+            }
+            return results.slice(0, maxResults);
+        }
+        catch {
+            return [];
+        }
+        finally {
+            clearTimeout(timer);
+        }
+    }
+}
+exports.DuckDuckGoProvider = DuckDuckGoProvider;

package/dist/src/notemd/search/SearchManager.js

@@ -0,0 +1,13 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SearchManager = void 0;
+const DuckDuckGoProvider_1 = require("./DuckDuckGoProvider");
+const TavilyProvider_1 = require("./TavilyProvider");
+class SearchManager {
+    static getProvider(searchProvider) {
+        if (searchProvider === 'tavily')
+            return new TavilyProvider_1.TavilyProvider();
+        return new DuckDuckGoProvider_1.DuckDuckGoProvider();
+    }
+}
+exports.SearchManager = SearchManager;

package/dist/src/notemd/search/SearchProvider.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/src/notemd/search/TavilyProvider.js

@@ -0,0 +1,44 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.TavilyProvider = void 0;
+class TavilyProvider {
+    constructor() {
+        this.name = 'tavily';
+    }
+    async search(query, apiKey, timeout = 45000) {
+        if (!apiKey)
+            throw new Error('Tavily API key is required.');
+        const maxResults = query.maxResults ?? 5;
+        const controller = new AbortController();
+        const timer = setTimeout(() => controller.abort(), timeout);
+        try {
+            const response = await fetch('https://api.tavily.com/search', {
+                method: 'POST',
+                headers: { 'Content-Type': 'application/json' },
+                body: JSON.stringify({
+                    api_key: apiKey,
+                    query: query.query,
+                    search_depth: query.searchDepth ?? 'basic',
+                    max_results: maxResults,
+                    include_answer: false,
+                    include_raw_content: false
+                }),
+                signal: controller.signal
+            });
+            if (!response.ok) {
+                const errorText = await response.text().catch(() => 'Unknown error');
+                throw new Error(`Tavily API error (${response.status}): ${errorText}`);
+            }
+            const data = (await response.json());
+            return (data.results ?? []).slice(0, maxResults).map(r => ({
+                title: r.title ?? '',
+                url: r.url,
+                content: r.content
+            }));
+        }
+        finally {
+            clearTimeout(timer);
+        }
+    }
+}
+exports.TavilyProvider = TavilyProvider;