fix(agent-core-v2): fall over to local engines when managed search auth fails

WebSearch resolved its provider eagerly: with a managed:kimi-code OAuth
entry present but no valid token, construction succeeded and the token
lookup only threw at search time — surfacing "No token for kimi-code"
and never reaching the always-available local engine chain (bing/baidu/
sogou/zhihu/csdn/juejin/linuxdo/startpage/brave/exa/duckduckgo).

Compose the candidates into a failover provider instead: auth/network
failures and empty result sets cascade to the next candidate, caller
aborts propagate immediately, and a sole candidate keeps its exact
behavior.

Author: luozihao

packages/agent-core-v2/src/app/auth/webSearch/webSearchService.ts

@@ -32,7 +32,18 @@ export class WebSearchProviderService implements IWebSearchProviderService {
   ) {}
 
   getWebSearchProvider(): WebSearchProvider | undefined {
-    return this.fromServicesConfig() ?? this.fromManagedOAuth() ?? this.localProvider();
+    const candidates: WebSearchProvider[] = [];
+    const services = this.fromServicesConfig();
+    if (services !== undefined) candidates.push(services);
+    let managed: WebSearchProvider | undefined;
+    try {
+      managed = this.fromManagedOAuth();
+    } catch {
+      managed = undefined;
+    }
+    if (managed !== undefined) candidates.push(managed);
+    candidates.push(this.localProvider());
+    return createFailoverWebSearchProvider(candidates);
   }
 
   hasWebSearchProvider(): boolean {
@@ -100,6 +111,33 @@ function nonEmptyString(value: string | undefined): string | undefined {
   return trimmed === undefined || trimmed.length === 0 ? undefined : trimmed;
 }
 
+/**
+ * Try each provider in order; an auth failure (missing/expired managed
+ * token) falls through to the next candidate instead of surfacing a
+ * dead-end, while caller aborts propagate immediately. Empty result sets
+ * also cascade — engines can legitimately miss a query.
+ */
+export function createFailoverWebSearchProvider(
+  candidates: readonly WebSearchProvider[],
+): WebSearchProvider {
+  return {
+    async search(query, options) {
+      let lastError: unknown = new Error('no search provider configured');
+      for (const candidate of candidates) {
+        try {
+          const results = await candidate.search(query, options);
+          if (results.length > 0 || candidates.length === 1) return results;
+          lastError = new Error('no search results');
+        } catch (error) {
+          if (options?.signal?.aborted) throw error;
+          lastError = error;
+        }
+      }
+      throw lastError;
+    },
+  };
+}
+
 registerScopedService(
   LifecycleScope.App,
   IWebSearchProviderService,

packages/agent-core-v2/test/app/auth/webSearch/failover.test.ts

@@ -0,0 +1,71 @@
+import { describe, expect, it } from 'vitest';
+
+import { createFailoverWebSearchProvider } from '#/app/auth/webSearch/webSearchService';
+import type { WebSearchProvider } from '#/agent/tools/web-search/web-search';
+
+function provider(
+  results: string[],
+  impl?: (query: string) => Promise<never> | void,
+): WebSearchProvider {
+  return {
+    async search(query) {
+      if (impl) await impl(query);
+      return results.map((title) => ({ title, url: `https://x/${title}`, snippet: '' }));
+    },
+  };
+}
+
+const abortError = Object.assign(new Error('aborted'), { name: 'AbortError' });
+
+describe('createFailoverWebSearchProvider', () => {
+  it('falls through to the next provider when the primary throws an auth failure', async () => {
+    const primary = provider([], () => {
+      throw new Error('No token for "kimi-code". Run /login to authenticate.');
+    });
+    const fallback = provider(['hit']);
+    const p = createFailoverWebSearchProvider([primary, fallback]);
+    const r = await p.search('q');
+    expect(r.map((x) => x.title)).toEqual(['hit']);
+  });
+
+  it('cascades when a candidate returns an empty result set', async () => {
+    const empty = provider([]);
+    const next = provider(['found']);
+    const p = createFailoverWebSearchProvider([empty, next]);
+    const r = await p.search('q');
+    expect(r.map((x) => x.title)).toEqual(['found']);
+  });
+
+  it('surfaces the last error when every candidate fails', async () => {
+    const boom = provider([], () => {
+      throw new Error('network down');
+    });
+    const p = createFailoverWebSearchProvider([boom, boom]);
+    await expect(p.search('q')).rejects.toThrow('network down');
+  });
+
+  it('rethrows caller aborts immediately without trying remaining providers', async () => {
+    let secondCalled = false;
+    const controller = new AbortController();
+    const slow = provider([], () => {
+      controller.abort();
+      return Promise.reject(abortError);
+    });
+    const second = {
+      async search() {
+        secondCalled = true;
+        return [];
+      },
+    };
+    const p = createFailoverWebSearchProvider([slow, second]);
+    await expect(p.search('q', { signal: controller.signal })).rejects.toBe(abortError);
+    expect(secondCalled).toBe(false);
+  });
+
+  it('returns the single candidate as-is behaviorally', async () => {
+    const only = provider(['solo']);
+    const p = createFailoverWebSearchProvider([only]);
+    const r = await p.search('q');
+    expect(r.map((x) => x.title)).toEqual(['solo']);
+  });
+});