dsh-web-search-pro 0.2.0 → 0.2.3

package/lib/router.js

@@ -4,8 +4,11 @@
  * @module web-search-pro/router
  */
 import { credentialRef } from '@deepseek-ai/dsh-credentials';
+import { effectiveChain } from "./default-chain.js";
 import { EngineError, } from "./engines.js";
-import { customKeyProblem, customPlatformAdapter } from "./providers/platforms.js";
+import { customCliAdapter, customCliProviderId, customKeyProblem, customPlatformAdapter } from "./providers/platforms.js";
+import { customCliPlatformIssues, isBackendId, platformBackendIssues } from "./cli/chains-spec.js";
+import { DEFAULT_CUSTOM_CONFIDENCE, resolveCliAdapters } from "./cli/spec.js";
 import { SourceUnavailableError } from "./providers/unavailable.js";
 import { defaultProviderRegistry, costTierOf, routeIdOf } from "./providers/index.js";
 import { BOCHA_FALLBACK_KEY_ENV, BOCHA_KEY_ENV } from "./providers/bocha.js";
@@ -22,8 +25,25 @@ import { createPlatformCacheKey, createSearchCacheKey } from "./cache-key.js";
 import { allAttemptsBenign, allAttemptsEmpty, BackendRegistry, NoBackendError } from "./backend-registry.js";
 import { ExaClient } from "./exa-client.js";
 import { SingleFlight } from "./singleflight.js";
-import { mergeCandidates } from "./pipeline/candidates.js";
+import { mergeCandidates, provenanceOf } from "./pipeline/candidates.js";
+import { guaranteeSeats } from "./pipeline/confidence.js";
 import { fuseCandidates } from "./pipeline/fusion.js";
+function originExtra(origin) {
+    return origin.via || origin.tag || origin.confidence !== undefined ? { origin } : {};
+}
+function originFromExtra(extra) {
+    if (!extra)
+        return {};
+    try {
+        const origin = JSON.parse(extra).origin;
+        return origin && typeof origin === 'object'
+            ? { ...typeof origin.via === 'string' ? { via: origin.via } : {}, ...typeof origin.tag === 'string' ? { tag: origin.tag } : {}, ...typeof origin.confidence === 'number' ? { confidence: origin.confidence } : {} }
+            : {};
+    }
+    catch {
+        return {};
+    }
+}
 export class SearchRouter {
     ctx;
     config;
@@ -40,6 +60,11 @@ export class SearchRouter {
     syncedRevision = -1;
     /** Custom platforms (settings `customPlatforms`) this router registered: key -> spec signature + unregister. A key the registry refused stays here with its problem so it is not retried on every call. */
     custom = new Map();
+    /** User-defined CLI adapters (settings `cliAdapters`) this router registered as `custom-cli:<id>` platforms, with the diagnostics of the entries it ignored. */
+    customCli = new Map();
+    cliAdapterDiagnostics = [];
+    /** Confidence of each registered custom CLI by route id (its spec's, default 0.5), rebuilt with the registrations. */
+    customConfidence = new Map();
     /** Latest local probe per route id (read by providerStatuses for the credential dimension). */
     readiness = new Map();
     /** Last real call per route id: feeds the health dimension (never inferred from a local probe). */
@@ -101,6 +126,35 @@ export class SearchRouter {
                 this.custom.set(key, { sig, off: () => { }, problem: 'custom platform "' + key + '" was not registered: ' + (error instanceof Error ? error.message : String(error)) });
             }
         }
+        this.syncCustomCliAdapters();
+    }
+    /** The same for `cliAdapters`: valid specs become `custom-cli:<id>` platforms; an invalid entry is ignored and reported. */
+    syncCustomCliAdapters() {
+        const { specs, diagnostics } = resolveCliAdapters(this.dynamic().cliAdapters);
+        this.cliAdapterDiagnostics = diagnostics;
+        this.customConfidence = new Map([...specs].map(([id, spec]) => [customCliProviderId(id), spec.confidence ?? DEFAULT_CUSTOM_CONFIDENCE]));
+        const next = new Map([...specs].map(([id, spec]) => [id, JSON.stringify(spec)]));
+        for (const [id, entry] of [...this.customCli])
+            if (next.get(id) !== entry.sig) {
+                entry.off();
+                this.customCli.delete(id);
+            }
+        for (const [id, sig] of next) {
+            if (this.customCli.has(id))
+                continue;
+            try {
+                this.customCli.set(id, { sig, off: this.registry.register(customCliAdapter(id, specs.get(id))) });
+            }
+            catch (error) {
+                this.customCli.set(id, { sig, off: () => { }, problem: 'cliAdapters.' + id + ' was not registered as ' + customCliProviderId(id) + ': ' + (error instanceof Error ? error.message : String(error)) });
+            }
+        }
+    }
+    /** Configuration problems of the CLI adapter layer for `sources.status`: ignored `cliAdapters` entries and `platformBackends` that name nothing usable. */
+    cliAdapterProblems() {
+        this.syncCustomPlatforms();
+        const cfg = this.dynamic();
+        return [...this.cliAdapterDiagnostics, ...[...this.customCli.values()].flatMap(entry => (entry.problem ? [entry.problem] : [])), ...customCliPlatformIssues(cfg.cliAdapters), ...platformBackendIssues(cfg.platformBackends, cfg.cliAdapters)];
     }
     /** Custom platforms the registry could not take (key clash, bad key), for `sources.status`. */
     customPlatformProblems() {
@@ -112,6 +166,9 @@ export class SearchRouter {
         for (const entry of this.custom.values())
             entry.off();
         this.custom.clear();
+        for (const entry of this.customCli.values())
+            entry.off();
+        this.customCli.clear();
     }
     backendFor(id) {
         return {
@@ -156,7 +213,9 @@ export class SearchRouter {
                     const outcome = await engine.search(input.query, input.count, input.signal, this.withBindings(id, input.options));
                     ticket?.settle(1, 'request counted by the router (the adapter booked none)');
                     this.outcomes.set(id, { ok: true, at: new Date().toISOString() });
-                    return { ...outcome, via: outcome.via ?? engine.id };
+                    // The source's confidence rides with every row it returned (only when below 1: the built-in sources add nothing).
+                    const confidence = this.confidenceOf(id, outcome.backend);
+                    return { ...outcome, via: outcome.via ?? engine.id, ...confidence < 1 ? { sources: outcome.sources.map(source => ({ ...source, confidence })) } : {} };
                 }
                 catch (error) {
                     const code = error?.code;
@@ -219,17 +278,53 @@ export class SearchRouter {
         return { deps: await this.deps(false), config: this.dynamic(), ...cli ? { cli } : {} };
     }
     /**
-     * The configured `engines` list with the user's `sources.*` preferences applied: disabled sources removed, `priority` ones that are
-     * already in the list moved to the front in their listed order. An explicit `engines` of a call never goes through this.
+     * The default engine order for a search that names no `engines`: the configured `engines` list with the user's `sources.*`
+     * preferences applied, then the default rule for "常用" (common) sources.
+     *  1. an explicit `engines` of a call never comes through here;
+     *  2. `sources.disabled` ids are removed, `sources.priority` ids that are in the list move to the front in their listed order;
+     *  3. a common source (DeepSeek Search) whose key resolves leads what is left, while `engines` is still the default list (a
+     *     list the user wrote is theirs: it keeps its order, and a common source in it keeps the position given). `sources.disabled`
+     *     and `evidence.sourcePolicy: anonymous-only` switch it off.
      */
-    preferred(ids) {
-        const src = this.dynamic().sources;
-        const disabled = new Set(this.canonicalIds(src?.disabled ?? []));
-        const kept = ids.filter(id => !disabled.has(id));
-        if (ids.length && !kept.length)
-            throw new Error('every configured engine is disabled (sources.disabled): ' + ids.join(', '));
-        const first = this.canonicalIds(src?.priority ?? []).filter(id => kept.includes(id));
-        return [...first, ...kept.filter(id => !first.includes(id))];
+    async preferred(ids) {
+        const cfg = this.dynamic();
+        const src = cfg.sources;
+        return effectiveChain({
+            engines: ids,
+            priority: this.canonicalIds(src?.priority ?? []),
+            disabled: this.canonicalIds(src?.disabled ?? []),
+            anonymousOnly: cfg.evidence?.sourcePolicy === 'anonymous-only',
+            commonReady: await this.commonReady(),
+        });
+    }
+    /** Route ids of the common ("常用") sources that are ready to run now (key resolved), best `priority` first. */
+    async commonReady() {
+        const common = this.registry.list({ operation: 'search' }).filter(a => a.descriptor.common && a.descriptor.kind !== 'platform');
+        if (!common.length)
+            return [];
+        const env = await this.probeEnv();
+        const out = [];
+        for (const adapter of common) {
+            try {
+                const readiness = await adapter.probeLocal(env);
+                if (readiness.available && readiness.credential === 'configured')
+                    out.push({ id: routeIdOf(adapter.descriptor), priority: adapter.descriptor.priority ?? 100 });
+            }
+            catch { /* a probe that throws is not ready */ }
+        }
+        return out.sort((a, b) => a.priority - b.priority).map(x => x.id);
+    }
+    /**
+     * Key and endpoint of the DeepSeek Fetch API for the fetch pipeline, or undefined when no key resolves (settings literal ->
+     * DSH credentials ref -> process environment, the same order as the search side). Resolved per call; the key is never cached.
+     */
+    async deepseekAccess() {
+        const cfg = this.dynamic();
+        const { sourceKeys, sourceBaseUrls } = await this.keyedSources(cfg, (ref, literal) => this.resolveKey(ref, literal));
+        const apiKey = sourceKeys?.deepseek;
+        if (!apiKey)
+            return undefined;
+        return { apiKey, ...sourceBaseUrls?.deepseek ? { baseUrl: sourceBaseUrls.deepseek } : {}, allowProxyFakeIp: cfg.allowProxyFakeIp, usage: this.usageRecorder() };
     }
     /** Alias / full id -> route id; ids the registry does not know are kept as written (the backend then reports them unknown). */
     canonicalIds(ids) {
@@ -242,10 +337,9 @@ export class SearchRouter {
             return diagnostics;
         const cfg = this.dynamic();
         const exaKey = await this.resolveKey(cfg.exaApiKeyEnv, cfg.exaApiKey);
+        // Platform providers (bilibili, youtube, ...) report their own chain readiness (src/cli/chain.ts); only Exa's MCP route is overruled here.
         const requiredCli = new Map([
             ...exaKey ? [] : [['exa', 'mcporter']],
-            ['bilibili', 'bili'],
-            ['youtube', 'yt-dlp'],
         ]);
         return diagnostics.map(diagnostic => {
             const dependency = requiredCli.get(diagnostic.id);
@@ -310,7 +404,7 @@ export class SearchRouter {
         try {
             const selected = await this.backends.runSelected({ query: call.query, count: call.count, signal: call.signal, skipSeam: opts.skipSeam ?? false, ...call.options ? { options: call.options } : {} }, { preferred: this.canonicalIds([call.id]), signal: call.signal });
             const sources = selected.value.sources;
-            return sources.length ? { state: 'ok', sources } : { state: 'empty' };
+            return sources.length ? { state: 'ok', sources, ...selected.value.backend ? { backend: selected.value.backend } : {}, ...selected.value.notes?.length ? { notes: selected.value.notes } : {} } : { state: 'empty' };
         }
         catch (error) {
             if (call.signal.aborted)
@@ -328,6 +422,33 @@ export class SearchRouter {
             return { state: 'error', message: error instanceof Error ? error.message : String(error) };
         }
     }
+    /**
+     * The credential variables of the CLI adapters under the names the tools read, each resolved like the plugin's other secrets:
+     * settings literal -> DSH credentials ref (`twitterAuthTokenEnv`) -> process environment. Values only ever reach a command's environment.
+     */
+    async cliEnv() {
+        const cfg = this.dynamic();
+        const out = {};
+        const authToken = await this.resolveKey(cfg.twitterAuthTokenEnv ?? 'TWITTER_AUTH_TOKEN', cfg.twitterAuthToken);
+        const ct0 = await this.resolveKey(cfg.twitterCt0Env ?? 'TWITTER_CT0', cfg.twitterCt0);
+        if (authToken)
+            out.TWITTER_AUTH_TOKEN = authToken;
+        if (ct0)
+            out.TWITTER_CT0 = ct0;
+        return out;
+    }
+    /** Sync twin of {@link cliEnv} for `available()` checks: settings literal and process environment only. */
+    cliEnvSync() {
+        const cfg = this.dynamic();
+        const out = {};
+        const authToken = cfg.twitterAuthToken || process.env[cfg.twitterAuthTokenEnv ?? 'TWITTER_AUTH_TOKEN'];
+        const ct0 = cfg.twitterCt0 || process.env[cfg.twitterCt0Env ?? 'TWITTER_CT0'];
+        if (authToken)
+            out.TWITTER_AUTH_TOKEN = authToken;
+        if (ct0)
+            out.TWITTER_CT0 = ct0;
+        return out;
+    }
     /** Resolve a key through credentials first, then process env. */
     async resolveKey(ref, literal) {
         if (literal && literal.length > 0)
@@ -357,8 +478,10 @@ export class SearchRouter {
         const semanticScholarApiKey = await this.resolveKey(SEMANTICSCHOLAR_KEY_ENV);
         const anysearchApiKey = await this.resolveKey(ANYSEARCH_KEY_ENV);
         const keyed = await this.keyedSources(cfg, (ref, literal) => this.resolveKey(ref, literal));
+        const cliEnv = await this.cliEnv();
         return {
             ...keyed,
+            ...Object.keys(cliEnv).length ? { cliEnv } : {},
             ...openalexApiKey ? { openalexApiKey } : {},
             ...semanticScholarApiKey ? { semanticScholarApiKey } : {},
             ...anysearchApiKey ? { anysearchApiKey } : {},
@@ -395,8 +518,10 @@ export class SearchRouter {
         const semanticScholarApiKey = process.env[SEMANTICSCHOLAR_KEY_ENV];
         const anysearchApiKey = process.env[ANYSEARCH_KEY_ENV];
         const keyed = this.keyedSourcesSync(cfg);
+        const cliEnv = this.cliEnvSync();
         return {
             ...keyed,
+            ...Object.keys(cliEnv).length ? { cliEnv } : {},
             ...openalexApiKey ? { openalexApiKey } : {},
             ...semanticScholarApiKey ? { semanticScholarApiKey } : {},
             ...anysearchApiKey ? { anysearchApiKey } : {},
@@ -477,8 +602,31 @@ export class SearchRouter {
     }
     /** Problems of the `sources.*` settings (unknown ids, bad numbers), for `sources.status`. */
     sourceDiagnostics() {
+        this.syncCustomPlatforms();
         const src = this.dynamic().sources;
-        return resolveSources({ priority: src?.priority, disabled: src?.disabled, budget: src?.budget }, id => this.registry.routeId(id) !== undefined).diagnostics;
+        return resolveSources({ priority: src?.priority, disabled: src?.disabled, budget: src?.budget, confidence: src?.confidence }, id => this.registry.routeId(id) !== undefined, isBackendId).diagnostics;
+    }
+    /** The confidence of one platform backend as a leg of a chain (`xhs`, `custom-cli:echo`): its own, without the provider's. */
+    backendConfidenceOf(id) {
+        return this.confidenceOf(id);
+    }
+    /** `sources.confidence` by canonical id (a provider's route id; a platform backend id as written), valid entries only. */
+    confidenceOverrides() {
+        const resolved = resolveSources({ confidence: this.dynamic().sources?.confidence }, id => this.registry.routeId(id) !== undefined, isBackendId);
+        return new Map(Object.entries(resolved.confidence).map(([id, value]) => [this.registry.routeId(id) ?? id, value]));
+    }
+    /**
+     * The confidence (0..1) of what `route` returned, through `backend` when it is a platform chain: `sources.confidence` of the
+     * provider times that of the backend that answered, each defaulting to the custom CLI's own (spec `confidence`, 0.5) and to 1
+     * for every built-in source, so the built-in ones are 1 unless the user set something.
+     */
+    confidenceOf(route, backend) {
+        this.syncCustomPlatforms();
+        const overrides = this.confidenceOverrides();
+        const own = (id) => overrides.get(id) ?? this.customConfidence.get(id) ?? 1;
+        const provider = this.registry.routeId(route) ?? route;
+        const via = backend === undefined || backend === provider ? undefined : this.registry.routeId(backend) ?? backend;
+        return Math.round(own(provider) * (via === undefined ? 1 : own(via)) * 10_000) / 10_000;
     }
     /** Counts a metered, non-model request (Bocha search) in the usage ledger; best effort, never throws into the search. */
     usageRecorder() {
@@ -544,19 +692,34 @@ export class SearchRouter {
             const health = cooling ? 'cooldown' : last ? (last.ok ? 'ready' : 'error') : 'unknown';
             const credential = last?.code === 'ENGINE_AUTH' ? 'rejected' : local.credential;
             const reason = !available ? (diag?.reason ?? local.reason) : undefined;
+            let chain;
+            let chainReport;
+            if (adapter.chain) {
+                try {
+                    chainReport = await adapter.chain(env);
+                    chain = chainReport.entries.map(entry => ({ ...entry, confidence: this.backendConfidenceOf(entry.id) }));
+                }
+                catch {
+                    chain = undefined;
+                }
+            }
             out.push({
                 id: d.id, route, aliases: [...d.aliases], label: d.label, kind: d.kind ?? 'web', ...d.domains?.length ? { domains: [...d.domains] } : {}, ...d.needsBrowser ? { needsBrowser: d.needsBrowser } : {}, operations: [...d.operations], taskProfiles: [...d.taskProfiles],
                 languages: [...d.languages], regions: [...d.regions], resultKinds: [...d.resultKinds],
                 ...d.sourceFamily ? { sourceFamily: d.sourceFamily } : {},
                 requirements: d.requirements.map(({ env, ...r }) => ({ ...r, ...env ? { env: [...env] } : {} })), supportedFilters: [...d.supportedFilters], costModel: { ...d.costModel }, costTier: local.costTier ?? costTierOf(d),
                 ...d.verification?.live ? {} : { unverified: true },
+                ...d.common ? { common: true } : {},
+                confidence: this.confidenceOf(route),
+                ...chain ? { chain } : {},
                 ...this.requestBudgetOf(route) ? { budget: this.requestBudgetOf(route) } : {},
                 readiness: {
                     available,
+                    ...chainReport ? { state: chainReport.state } : {},
                     ...local.installation ? { installation: local.installation } : {},
                     ...credential ? { credential } : {},
                     health,
-                    ...reason ? { reason } : {},
+                    ...reason ? { reason } : chainReport?.state === 'login_unverified' && chainReport.reason ? { reason: chainReport.reason } : {},
                     ...local.diagnosticCode ? { diagnosticCode: local.diagnosticCode } : {},
                     lastLocalCheck: now,
                     ...last?.ok ? { lastRemoteSuccess: last.at } : {},
@@ -575,7 +738,7 @@ export class SearchRouter {
         const query = platform ? platform.query : opts.query.trim();
         if (!platform && !query)
             throw new Error('query must be a non-empty string');
-        const ids = platform ? [platform.id] : opts.engines && opts.engines.length ? this.canonicalIds(opts.engines) : this.preferred(this.canonicalIds(cfg.engines));
+        const ids = platform ? [platform.id] : opts.engines && opts.engines.length ? this.canonicalIds(opts.engines) : await this.preferred(this.canonicalIds(cfg.engines));
         const nq = normQuery(platform ? query || platform.url || platform.id : query);
         const count = Math.min(Math.max(opts.count, 1), 20);
         const multi = !platform && opts.multi && ids.length > 1;
@@ -628,11 +791,12 @@ export class SearchRouter {
                 if (detail?.requestedCount === undefined || detail.requestedCount >= count) {
                     const result = {
                         ...detail?.content ? { content: detail.content } : {},
-                        sources: shapeSources(cached.rows.map(r => ({ url: r.url, title: r.title, snippet: r.snippet, publishedAt: r.published })), count),
+                        sources: shapeSources(cached.rows.map(r => ({ url: r.url, title: r.title, snippet: r.snippet, publishedAt: r.published, ...originFromExtra(r.extra) })), count),
                         engine: detail?.engine ?? ids[0] ?? 'unknown',
                         enginesTried: detail?.enginesTried ?? ids,
                         fromCache: true,
                         availableCount: cached.rows.length,
+                        ...detail?.backend ? { backend: detail.backend } : {},
                         ...detail?.fallbackNote ? { fallbackNote: detail.fallbackNote } : {},
                     };
                     this.memory.set(memoryKey, result);
@@ -648,6 +812,7 @@ export class SearchRouter {
         let fallbackNote;
         let availableCount;
         let persistExtras;
+        let backendId;
         if (multi) {
             // Every engine goes through the registry (probe, cooldown, quality gate,
             // attempts) in parallel; failures of one never cancel the others.
@@ -674,18 +839,19 @@ export class SearchRouter {
                 throw new Error('all engines failed: ' + failures);
             }
             const merged = mergeCandidates(outputs);
-            const ranked = fuseCandidates(merged, {
+            // A source with a confidence below 1 weighs a little less in the fusion, and its best result keeps a place in the list (confidence.ts).
+            const ranked = guaranteeSeats(fuseCandidates(merged, {
                 k: cfg.rrfConstant,
                 freshnessBoost: cfg.freshnessBoost,
                 freshnessDays: cfg.freshnessDays,
                 authorityBoost: cfg.authorityBoost,
                 authorityDomains: cfg.authorityDomains,
                 nProviders: outputs.length,
-            }).slice(0, count);
+            }), count, ranked => ranked.candidate.contributions).slice(0, count);
             availableCount = merged.length;
-            outcome = { sources: ranked.map(({ candidate }) => ({ url: candidate.url, ...candidate.title ? { title: candidate.title } : {}, ...candidate.snippet ? { snippet: candidate.snippet } : {}, ...candidate.publishedAt ? { publishedAt: candidate.publishedAt } : {} })) };
-            // Per-source provenance survives in results.extra (no schema change); the cache-hit path ignores it.
-            persistExtras = ranked.map(({ candidate, score }) => JSON.stringify({ contributions: candidate.contributions, score: Number(score.toFixed(6)) }));
+            outcome = { sources: ranked.map(({ candidate }) => ({ url: candidate.url, ...candidate.title ? { title: candidate.title } : {}, ...candidate.snippet ? { snippet: candidate.snippet } : {}, ...candidate.publishedAt ? { publishedAt: candidate.publishedAt } : {}, ...provenanceOf(candidate) })) };
+            // Per-source provenance survives in results.extra (no schema change); a cache hit reads back the origin (`via`, `tag`, `confidence`) from it.
+            persistExtras = ranked.map(({ candidate, score }) => JSON.stringify({ contributions: candidate.contributions, score: Number(score.toFixed(6)), ...originExtra(provenanceOf(candidate)) }));
             usedId = 'multi(' + ids.join('+') + ')';
         }
         else {
@@ -701,6 +867,8 @@ export class SearchRouter {
                 outcome = selected.value;
                 usedId = platform ? platform.id : selected.id;
                 viaId = selected.value.via ?? selected.id;
+                if (platform)
+                    backendId = selected.value.backend ?? viaId;
                 enginesTried.push(...ids.slice(0, Math.max(ids.indexOf(selected.id) + 1, 1)));
                 // P1-1: explain the fallback (e.g. ddg returned results but none had snippets). A single platform has nothing to fall back to.
                 const lowQualityAttempts = platform ? [] : selected.attempts.filter(a => a.outcome === 'low-quality');
@@ -714,6 +882,10 @@ export class SearchRouter {
                 const spent = selected.attempts.filter(a => a.outcome === 'skipped' && /request budget used up/.test(a.detail ?? ''));
                 if (spent.length)
                     fallbackNote = (fallbackNote ? fallbackNote + '\n' : '') + 'skipped: ' + spent.map(a => a.id + ': ' + a.detail).join('; ');
+                // Notes of the engine itself: chain legs passed over (with reasons), results dropped for lack of a link.
+                const engineNotes = selected.value.notes ?? [];
+                if (engineNotes.length)
+                    fallbackNote = (fallbackNote ? fallbackNote + '\n' : '') + engineNotes.join('\n');
             }
             catch (error) {
                 if (signal?.aborted)
@@ -743,8 +915,11 @@ export class SearchRouter {
             engine: platform ? viaId ?? finalId : finalId,
             status: 'ok',
             cacheKey,
-            detail: JSON.stringify({ ...finalOutcome.content ? { content: finalOutcome.content } : {}, engine: finalId, enginesTried, requestedCount: count, ...fallbackNote ? { fallbackNote } : {} }),
-        }, persistExtras ? finalOutcome.sources.map((source, i) => ({ ...source, extra: persistExtras[i] })) : finalOutcome.sources, platform ? 'platform-' + platform.id : finalId));
+            detail: JSON.stringify({ ...finalOutcome.content ? { content: finalOutcome.content } : {}, engine: finalId, ...backendId ? { backend: backendId } : {}, enginesTried, requestedCount: count, ...fallbackNote ? { fallbackNote } : {} }),
+        }, finalOutcome.sources.map((source, i) => {
+            const extra = persistExtras ? persistExtras[i] : JSON.stringify(originExtra({ ...source.via ? { via: source.via } : {}, ...source.tag ? { tag: source.tag } : {}, ...source.confidence !== undefined ? { confidence: source.confidence } : {} }));
+            return extra === '{}' ? source : { ...source, extra };
+        }), platform ? 'platform-' + platform.id : finalId));
         const result = {
             ...outcome.content ? { content: outcome.content } : {},
             sources: shapeSources(outcome.sources, count),
@@ -752,6 +927,7 @@ export class SearchRouter {
             enginesTried,
             fromCache: false,
             availableCount,
+            ...backendId ? { backend: backendId } : {},
             ...fallbackNote ? { fallbackNote } : {},
         };
         // 4. Warm the in-process LRU (memory-only; survives across SQLite hits).