dsh-mcp-connector 0.2.43 → 0.2.45

package/CHANGELOG.md

@@ -4,6 +4,41 @@
 
 ## [Unreleased]
 
+## [0.2.45] - 2026-09-12
+
+### Added
+
+- 新增“工具”页：跨连接统一搜索、精确工具名优先、连接/服务/发现状态筛选及分页；搜索与筛选仅读取缓存，不访问远端服务。
+- 结果展示连接与服务来源、最后成功缓存时间及最近发现状态；故障连接保留缓存，并提供单连接“重新发现工具”和“检查连接”入口及已有诊断建议。
+- 参数详情增加类型、必填、枚举、约束和可展开嵌套结构；复杂或超大结构提示摘要限制，同时保留原始安全缓存 Schema。
+
+### Changed
+
+- 后台最多并发两条连接；健康连接五分钟到期，普通故障从三十秒指数退避至十五分钟，429 遵守 Retry-After，鉴权失败暂停自动重试。
+- 手动故障处理合并同连接并发请求、设置五秒冷却，不能绕过限流等待。未选择 Workspace 的工具页仅展示全局连接。
+
+### Verification
+
+- 248 项自动测试通过，覆盖工作区隔离、精确搜索、分页、只读搜索零远端请求、单连接诊断及 429 等待；72 个发布文件通过白名单与敏感内容扫描。
+- 本机无凭据模拟页面验证多服务汇总、搜索筛选、参数详情及恢复后状态同步；未执行目标工具，未更改真实 web profile。
+- 确定性调度模型中，六条健康连接持续查看十分钟从 126 次降至 18 次发现任务；此为策略模型验证，不是生产性能基准。
+
+## [0.2.44] - 2026-09-12
+
+### Added
+
+- 启动恢复及连接成功后后台发现工具，无需先打开详情；后台最多并行发现两个连接器，同一连接的并发 HTTP 发现合并。
+- 手动、JSON 导入和目录连接统一支持工具列表、搜索与详情，可按 connectionKey 精确定位；已安装页增加工具入口。
+- SSE 订阅期间每 30 秒重新发现以恢复断线状态；详情读取只读快照、重连后补同步，不形成事件刷新循环。
+
+### Fixed
+
+- 页面与 API 使用一致的搜索评分，精确工具名优先；后台发现中、读取失败与成功空列表分别展示。
+- Schema 清理区分参数名称与关键字，保留名为 default、const、examples 的合法参数；敏感默认值及示例仍不缓存。
+- 连接配置变更后失效旧缓存，忽略断开或重配期间返回的过期发现结果；查询继续遵守工作区可见范围。
+
+本次不新增目标工具执行、跨连接器搜索页面或凭据分享能力。
+
 ## [0.2.43] - 2026-09-12
 
 ### Added

package/README.en.md

@@ -8,6 +8,12 @@ Manage MCP connections from different providers in one place inside DeepSeek Har
 
 [简体中文](README.md)
 
+### Tool discovery and troubleshooting
+
+The Tools tab searches cached tools across connections, with connection, service and discovery-status filters. Results show their source and last successful cache time. Readable parameter summaries retain access to the original sanitized schema. Browsing never executes tools; cached availability does not guarantee a live call will succeed.
+
+Expand connection diagnostics to check a connection or rediscover its tools. Healthy background discovery is due every five minutes; failures back off, rate limits honor Retry-After, and authentication failures pause automatic retries. Without a selected workspace, only global connections appear.
+
 [Chinese user guide](docs/USER-GUIDE.md) · [Connector onboarding](https://github.com/duhu2000/dsh-mcp-connector-registry/blob/main/docs/ONBOARDING.md) · [First contribution](docs/FIRST-CONTRIBUTION.md) · [Contributing](CONTRIBUTING.md) · [Issues](https://github.com/duhu2000/dsh-mcp-connector/issues)
 
 [![CI](https://github.com/duhu2000/dsh-mcp-connector/actions/workflows/ci.yml/badge.svg)](https://github.com/duhu2000/dsh-mcp-connector/actions/workflows/ci.yml)
@@ -178,7 +184,7 @@ npm run dev:ui
 
 Every Registry merge regenerates `catalog-stats.json`; an hourly workflow in this repository synchronizes the Chinese and English product copy plus a local stats snapshot. The static npm README updates with package releases, while the live badges above read the Registry directly and therefore stay current without another npm release.
 
-The current public version is [`dsh-mcp-connector@0.2.43`](https://www.npmjs.com/package/dsh-mcp-connector), with [GitHub Release v0.2.43](https://github.com/duhu2000/dsh-mcp-connector/releases/tag/v0.2.43).
+The current public version is [`dsh-mcp-connector@0.2.45`](https://www.npmjs.com/package/dsh-mcp-connector), with [GitHub Release v0.2.45](https://github.com/duhu2000/dsh-mcp-connector/releases/tag/v0.2.45).
 
 See [CHANGELOG.md](CHANGELOG.md) for version history and [docs/DESKTOP-E2E.md](docs/DESKTOP-E2E.md) for the Desktop release checklist.
 

package/README.md

@@ -8,6 +8,12 @@
 
 [English](README.en.md)
 
+### 工具查找与故障处理
+
+打开“工具”页可跨连接搜索工具，并按连接、服务和最近发现状态筛选。结果标注来源与最后成功缓存时间；缓存可查不代表服务当前可调用。参数详情提供易读摘要与原始安全 Schema，不执行工具。
+
+遇到故障时展开“连接状态与故障处理”，按诊断建议使用“检查连接”或“重新发现工具”。后台健康连接每五分钟到期，失败指数退避；限流遵守 Retry-After，鉴权失败暂停自动重试。未选择工作区时仅显示全局连接。
+
 [用户手册](docs/USER-GUIDE.md) · [第三方连接器上架指南](https://github.com/duhu2000/dsh-mcp-connector-registry/blob/main/docs/ONBOARDING.md) · [首次贡献](docs/FIRST-CONTRIBUTION.md) · [参与贡献](CONTRIBUTING.md) · [问题反馈](https://github.com/duhu2000/dsh-mcp-connector/issues)
 
 [![CI](https://github.com/duhu2000/dsh-mcp-connector/actions/workflows/ci.yml/badge.svg)](https://github.com/duhu2000/dsh-mcp-connector/actions/workflows/ci.yml)
@@ -173,7 +179,7 @@ npm run dev:ui
 
 公共 Registry 每次合并后会生成 `catalog-stats.json`；本仓库的定时工作流每小时同步中英文介绍和统计快照。npm 页面中的静态正文随版本发布更新，上方动态统计徽标则直接读取 Registry，可在不发布新 npm 版本时保持实时数量一致。
 
-当前公开版本为 [`dsh-mcp-connector@0.2.43`](https://www.npmjs.com/package/dsh-mcp-connector)，对应 [GitHub Release v0.2.43](https://github.com/duhu2000/dsh-mcp-connector/releases/tag/v0.2.43)。
+当前公开版本为 [`dsh-mcp-connector@0.2.45`](https://www.npmjs.com/package/dsh-mcp-connector)，对应 [GitHub Release v0.2.45](https://github.com/duhu2000/dsh-mcp-connector/releases/tag/v0.2.45)。
 
 版本能力与变更记录见 [CHANGELOG.md](CHANGELOG.md)。
 Desktop 发版回归见 [docs/DESKTOP-E2E.md](docs/DESKTOP-E2E.md)。

package/lib/discovery-policy.js

@@ -0,0 +1,21 @@
+// Pure scheduling policy. No credentials, timers or network operations.
+export function nextDiscovery(previous, outcome, now = Date.now()) {
+  const failures = outcome.ok ? 0 : Math.min((previous?.failures || 0) + 1, 10);
+  if (outcome.errorKind === 'auth') return { failures, nextAt: null, reason: 'auth' };
+  const rateLimited = outcome.errorKind === 'rate-limit';
+  const delay = outcome.ok ? 300_000 : Math.min((rateLimited ? 60_000 : 30_000) * 2 ** (failures - 1), 900_000);
+  const retry = Number.isFinite(outcome.retryAfterMs) ? Math.max(0, outcome.retryAfterMs) : 0;
+  return { failures, nextAt: now + Math.max(delay, retry), reason: outcome.ok ? 'success' : rateLimited ? 'rate-limit' : 'retry' };
+}
+
+export function discoveryDue(plan, now = Date.now()) {
+  return !plan || (plan.nextAt !== null && plan.nextAt <= now);
+}
+
+export function parseRetryAfter(value, now = Date.now()) {
+  if (!value) return 0;
+  const seconds = Number(value);
+  const delay = Number.isFinite(seconds) ? seconds * 1000 : Date.parse(value) - now;
+  // Bound untrusted headers; malformed/negative values fall back to local backoff.
+  return Number.isFinite(delay) ? Math.max(0, Math.min(delay, 86_400_000)) : 0;
+}

package/lib/index.js

@@ -69,8 +69,10 @@ import {
   scopeTargets,
 } from './connection-scopes.js';
 import { installConnectorSettings } from './settings.js';
+import { nextDiscovery, discoveryDue } from './discovery-policy.js';
 import {
   connectionToolCacheSignature,
+  browseToolCatalog,
   createToolCatalogRecord,
   findToolDetails,
   searchToolCatalog,
@@ -166,8 +168,14 @@ export async function apply(ctx, config) {
     warnedLegacyConflicts: new Set(),
     toolInventories: new Map(),  // serverName -> { observed, observedAt, tools: Set<rawName> }
     toolCatalogCache: new Map(), // connection key -> 最近成功、安全裁剪后的工具元数据
+    toolViews: new Map(), // connection key -> last discovery outcome (memory only)
   };
   const statusEvents = new StatusEventHub();
+  const toolRequests = new Map();
+  const discoveryPlans = new Map();
+  const connectionChecks = new Map();
+  const explorerActions = new Map();
+  const explorerActionTimes = new Map();
 
   const hostGovernance = createHostGovernanceController(ctx, {
     getRules: () => governancePolicies.snapshot().rules,
@@ -603,6 +611,13 @@ export async function apply(ctx, config) {
   async function persistRecord(record) {
     // 存储成功后才更新内存，避免落盘失败却在当前进程显示为“已安装”。
     if (config.persistSecrets) await connectionStore.put(record);
+    const previous = state.connections.get(record.key);
+    if (previous && (connectionToolCacheSignature(previous) !== connectionToolCacheSignature(record)
+        || JSON.stringify(previous.auth) !== JSON.stringify(record.auth)
+        || JSON.stringify(previous.headers) !== JSON.stringify(record.headers)
+        || JSON.stringify(previous.env) !== JSON.stringify(record.env))) {
+      await deleteLastSuccessfulTools(record.key);
+    }
     state.connections.set(record.key, record);
     clearRecordHealth(record);
   }
@@ -984,6 +999,8 @@ export async function apply(ctx, config) {
   }
 
   async function cacheLastSuccessfulTools(record, tools) {
+    // A request may finish after disconnect/reconfigure. Never resurrect old metadata.
+    if (state.connections.get(record.key) !== record || record.enabled === false) return null;
     const entry = createToolCatalogRecord(record, tools);
     state.toolCatalogCache.set(record.key, entry);
     if (config.persistSecrets) {
@@ -997,6 +1014,9 @@ export async function apply(ctx, config) {
   }
 
   async function deleteLastSuccessfulTools(key) {
+    discoveryPlans.delete(key);
+    connectionChecks.delete(key);
+    state.toolViews.delete(key);
     state.toolCatalogCache.delete(key);
     if (config.persistSecrets) {
       await toolCatalogStore.delete(key).catch((error) => {
@@ -1014,9 +1034,10 @@ export async function apply(ctx, config) {
     return { entry, ...toolCatalogCacheView(entry) };
   }
 
-  function visibleToolCatalogEntries(workspaceId) {
+  function visibleToolCatalogEntries(workspaceId, connectionKey) {
     const entries = [];
     for (const record of state.connections.values()) {
+      if (connectionKey && record.key !== connectionKey) continue;
       if (record.enabled === false) continue;
       if (workspaceId && !connectionVisibleInWorkspace(connectionScopes.binding(record.key), workspaceId)) continue;
       const cached = cachedToolsForRecord(record);
@@ -1025,6 +1046,38 @@ export async function apply(ctx, config) {
     return entries;
   }
 
+  function explorerRecords(workspaceId) {
+    // Unlike the legacy management overview, no Workspace means global-only.
+    return [...state.connections.values()].filter((record) => record.enabled !== false
+      && connectionVisibleInWorkspace(connectionScopes.binding(record.key), workspaceId));
+  }
+
+  function explorerConnection(record) {
+    const view = state.toolViews.get(record.key);
+    const server = view?.record === record ? view.server : null;
+    const cache = cachedToolsForRecord(record);
+    const plan = discoveryPlans.get(record.key);
+    const currentPlan = plan?.record === record ? plan : null;
+    const check = connectionChecks.get(record.key);
+    const diagnostic = check?.record === record && (!view || check.at >= view.at)
+      ? check.summary.diagnostic
+      : server ? buildHealthSummary({ connectorId: record.connectorId, records: [record], results: [{
+          ok: server.ok || server.unknown, kind: server.unknown ? 'managed' : server.ok ? 'connected' : server.errorKind || 'network',
+          code: server.diagnosticCode, serverName: record.serverName, serverKey: record.serverKey, message: server.error,
+        }], checkedAt: view.at }).diagnostic : null;
+    const status = !server ? 'pending' : server.unknown ? 'unknown' : server.ok ? 'success' : 'failed';
+    return {
+      connectionKey: record.key, connectionName: record.name, connectorId: record.connectorId,
+      connectorName: state.merged.find((item) => item.id === record.connectorId)?.name || record.name,
+      serverName: record.serverName, transport: record.transport, status,
+      checkedAt: view?.record === record ? view.at : null,
+      observedAt: cache?.observedAt || null, stale: cache?.stale || false,
+      toolCount: cache?.entry.tools.length || 0, cacheTruncated: cache?.entry.truncated === true,
+      diagnostic, nextDiscoveryAt: currentPlan?.nextAt ?? null,
+      retryReason: currentPlan?.reason || null,
+    };
+  }
+
   function readinessResults(records, validationResults = []) {
     return records.map((record, index) => {
       const validated = validationResults[index];
@@ -2298,13 +2351,17 @@ export async function apply(ctx, config) {
       };
     },
 
-    async healthCheck(connectorId) {
+    async healthCheck(connectorId, workspaceId, connectionKey) {
+      if (connectionKey && !explorerRecords(workspaceId).some((record) => record.key === connectionKey && record.connectorId === connectorId)) {
+        return { ok: false, message: '连接不存在、已停用或当前工作区不可见' };
+      }
       const targetIds = connectorId
         ? [String(connectorId)]
         : [...new Set([...state.connections.values()].map((record) => record.connectorId).filter(Boolean))];
       const summaries = [];
       for (const id of targetIds) {
-        const records = [...state.connections.values()].filter((record) => record.connectorId === id);
+        const records = [...state.connections.values()].filter((record) => record.connectorId === id
+          && (!connectionKey || record.key === connectionKey));
         const enabledRecords = records.filter((record) => record.enabled !== false);
         if (records.length === 0 || enabledRecords.length === 0) {
           const summary = healthSummary(id, records, [], Date.now());
@@ -2356,7 +2413,19 @@ export async function apply(ctx, config) {
           });
           checkedResults = validation.detail.results;
         }
-        summaries.push(cacheHealth(id, records, [...immediateResults, ...checkedResults]));
+        const summary = connectionKey ? healthSummary(id, records, [...immediateResults, ...checkedResults], Date.now())
+          : cacheHealth(id, records, [...immediateResults, ...checkedResults]);
+        if (connectionKey && state.connections.get(connectionKey) === records[0]) {
+          connectionChecks.set(connectionKey, { record: records[0], summary, at: Date.now() });
+          const outcome = [...immediateResults, ...checkedResults][0];
+          if (outcome && !outcome.ok) {
+            const prior = discoveryPlans.get(connectionKey);
+            discoveryPlans.set(connectionKey, { record: records[0], ...nextDiscovery(prior?.record === records[0] ? prior : null, { ok: false, errorKind: outcome.kind, retryAfterMs: outcome.retryAfterMs }) });
+          } else if (discoveryPlans.get(connectionKey)?.reason === 'auth') {
+            discoveryPlans.delete(connectionKey); scheduleDiscovery();
+          }
+        }
+        summaries.push(summary);
       }
       const healthy = summaries.filter((item) => item.connectionState === 'healthy').length;
       const unknown = summaries.filter((item) => item.connectionState === 'unknown').length;
@@ -2641,26 +2710,82 @@ export async function apply(ctx, config) {
       return { ok: true, message: `已将 "${connector.name}" ${published ? '上架' : '下架'}` };
     },
 
+    async toolExplorer(input = {}) {
+      const records = explorerRecords(input.workspaceId);
+      const connections = records.map(explorerConnection);
+      const selected = records.filter((record) => (!input.connectionKey || record.key === input.connectionKey)
+        && (!input.serverName || record.serverName === input.serverName)
+        && (!input.status || explorerConnection(record).status === input.status));
+      const entries = selected.map((record) => cachedToolsForRecord(record)?.entry).filter(Boolean);
+      const result = browseToolCatalog(entries, { query: input.query, offset: input.offset, limit: input.limit });
+      const byKey = new Map(connections.map((item) => [item.connectionKey, item]));
+      return { ok: true, message: `找到 ${result.total} 个工具`, detail: {
+        ...result, items: result.items.map((item) => ({ ...item, connection: byKey.get(item.connectionKey) })),
+        connections, selectedConnections: selected.map(explorerConnection), discoveryOnly: true,
+        scopeLabel: input.workspaceId ? '当前工作区可见连接' : '全局连接（未选择工作区）',
+      } };
+    },
+
+    async toolExplorerDetail(input = {}) {
+      if (!explorerRecords(input.workspaceId).some((record) => record.key === input.connectionKey)) {
+        return { ok: false, message: '连接不存在、已停用或当前工作区不可见' };
+      }
+      return api.toolDetail(input);
+    },
+
+    async toolExplorerAction(input = {}) {
+      const record = explorerRecords(input.workspaceId).find((item) => item.key === input.connectionKey);
+      if (!record || !['discover', 'check'].includes(input.action)) return { ok: false, message: '操作无效或连接当前不可见' };
+      const pending = explorerActions.get(record);
+      if (pending) return pending;
+      const plan = discoveryPlans.get(record.key);
+      if (plan?.record === record && plan.reason === 'rate-limit' && !discoveryDue(plan)) {
+        return { ok: false, message: '服务正在限流，请等待下一次允许重试时间', detail: { retryAt: plan.nextAt } };
+      }
+      if (Date.now() - (explorerActionTimes.get(record.key) || 0) < 5_000) return { ok: false, message: '操作过于频繁，请稍后重试' };
+      explorerActionTimes.set(record.key, Date.now());
+      const request = input.action === 'discover'
+        ? api.toolsList(record.connectorId, input.workspaceId, false, record.key)
+        : api.healthCheck(record.connectorId, input.workspaceId, record.key);
+      explorerActions.set(record, request);
+      try { return await request; }
+      finally { explorerActions.delete(record); statusEvents.publish(input.action === 'discover' ? 'tools' : 'status'); }
+    },
+
     async toolSearch(input = {}) {
       try {
         const connectorId = String(input.connectorId ?? '').trim() || undefined;
-        if (connectorId && !state.merged.some((connector) => connector.id === connectorId)) {
+        if (connectorId && !state.merged.some((connector) => connector.id === connectorId)
+            && ![...state.connections.values()].some((record) => record.connectorId === connectorId
+              && record.enabled !== false && (!input.workspaceId || connectionVisibleInWorkspace(connectionScopes.binding(record.key), input.workspaceId)))) {
           return { ok: false, message: `连接器 "${connectorId}" 不存在` };
         }
-        const items = searchToolCatalog(visibleToolCatalogEntries(input.workspaceId), {
+        const items = searchToolCatalog(visibleToolCatalogEntries(input.workspaceId, input.connectionKey), {
           query: input.query,
           connectorId,
           limit: input.limit,
         });
         const staleCount = items.filter((item) => item.stale).length;
+        const visibleRecords = [...state.connections.values()].filter((record) => record.enabled !== false
+          && (!connectorId || record.connectorId === connectorId)
+          && (!input.connectionKey || record.key === input.connectionKey)
+          && (!input.workspaceId || connectionVisibleInWorkspace(connectionScopes.binding(record.key), input.workspaceId)));
+        const pendingServers = visibleRecords.filter((record) => !cachedToolsForRecord(record)
+          && state.toolViews.get(record.key)?.record !== record).length;
+        const failedServers = visibleRecords.filter((record) => {
+          const view = state.toolViews.get(record.key);
+          return view?.record === record && !view.server.ok;
+        }).length;
         return {
           ok: true,
-          message: `最后成功工具缓存中找到 ${items.length} 个匹配项${staleCount ? `，其中 ${staleCount} 个已超过 24 小时` : ''}`,
+          message: `最后成功工具缓存中找到 ${items.length} 个匹配项${staleCount ? `，其中 ${staleCount} 个已超过 24 小时` : ''}${pendingServers ? `；${pendingServers} 个服务正在后台发现` : ''}${failedServers ? `；${failedServers} 个服务最近读取失败` : ''}`,
           detail: {
             items,
             source: 'last-success-cache',
             discoveryOnly: true,
             credentialsStored: false,
+            pendingServers,
+            failedServers,
           },
         };
       } catch (error) {
@@ -2672,7 +2797,7 @@ export async function apply(ctx, config) {
       try {
         const connectorId = String(input.connectorId ?? '').trim() || undefined;
         const serverName = String(input.serverName ?? '').trim() || undefined;
-        const matches = findToolDetails(visibleToolCatalogEntries(input.workspaceId), {
+        const matches = findToolDetails(visibleToolCatalogEntries(input.workspaceId, input.connectionKey), {
           toolName: input.toolName,
           connectorId,
           serverName,
@@ -2709,15 +2834,40 @@ export async function apply(ctx, config) {
      * 从已连接的 MCP server 动态获取工具清单
      * 通过 MCP JSON-RPC 协议调用 tools/list 方法
      */
-    async toolsList(connectorId, workspaceId) {
+    async toolsList(connectorId, workspaceId, cachedOnly = false, connectionKey) {
       const connector = state.merged.find((d) => d.id === connectorId);
-      if (!connector) return { ok: false, message: `连接器 "${connectorId}" 不存在` };
 
       const records = [...state.connections.values()].filter((record) => (
         record.connectorId === connectorId
+        && (!connectionKey || record.key === connectionKey)
         && record.enabled !== false
         && (!workspaceId || connectionVisibleInWorkspace(connectionScopes.binding(record.key), workspaceId))
       ));
+      if (connectionKey && !records.length) return { ok: false, message: '连接不存在、已停用或当前工作区不可见' };
+      if (!connector && !records.length) return { ok: false, message: `连接器 "${connectorId}" 不存在或当前工作区不可见` };
+      if (cachedOnly && records.length) {
+        const servers = records.map((record) => {
+          const cached = cachedToolsForRecord(record);
+          const view = state.toolViews.get(record.key);
+          const current = view?.record === record ? view.server : null;
+          return {
+            serverKey: record.serverKey || record.name, serverName: record.serverName,
+            ok: current?.ok === true, cached: Boolean(cached),
+            unknown: !current || current.unknown === true,
+            pending: !current && !cached,
+            error: current?.error || (!cached && !current ? '正在后台发现工具，请稍候' : undefined),
+            policy: serverPolicy(record),
+            ...(cached ? { cacheObservedAt: cached.observedAt, cacheAgeMs: cached.cacheAgeMs, stale: cached.stale } : {}),
+            tools: (cached?.entry.tools || []).map((tool) => decorateToolPolicy(record, {
+              name: tool.name, title: tool.title || tool.name, description: tool.description || '',
+            })),
+          };
+        });
+        return { ok: servers.some((server) => server.ok), message: '最近工具发现状态', detail: {
+          connectorId, servers, totalTools: servers.reduce((sum, server) => sum + server.tools.length, 0),
+          source: 'last-success-cache',
+        } };
+      }
       if (!records.length) {
         const servers = (connector.toolsSnapshot ?? []).map((snapshot) => ({
           serverKey: snapshot.serverKey,
@@ -2740,7 +2890,7 @@ export async function apply(ctx, config) {
       for (const record of records) {
         if (record.transport === 'stdio') {
           const registered = registeredStdioTools(record);
-          const snapshot = (connector.toolsSnapshot ?? []).find((item) =>
+          const snapshot = (connector?.toolsSnapshot ?? []).find((item) =>
             item.serverKey === record.serverKey || item.serverName === record.serverName);
           const liveTools = registered.tools;
           let cached = cachedToolsForRecord(record);
@@ -2795,10 +2945,14 @@ export async function apply(ctx, config) {
           continue;
         }
         try {
-          const listed = await listMcpTools(record, {
-            timeoutMs: config.requestTimeoutMs,
-            grants: grantMap(),
-          });
+          let request = toolRequests.get(record);
+          if (!request) {
+            request = listMcpTools(record, { timeoutMs: config.requestTimeoutMs, grants: grantMap() });
+            toolRequests.set(record, request);
+          }
+          let listed;
+          try { listed = await request; }
+          finally { if (toolRequests.get(record) === request) toolRequests.delete(record); }
           state.toolInventories.set(record.serverName, {
             observed: true,
             observedAt: Date.now(),
@@ -2837,6 +2991,7 @@ export async function apply(ctx, config) {
               ok: false,
               error: error.message,
               errorKind: error.kind,
+              retryAfterMs: error.retryAfterMs,
               policy: serverPolicy(record),
               ...cachedFields,
             });
@@ -2847,6 +3002,17 @@ export async function apply(ctx, config) {
         }
       }
 
+      if (records.some((record) => state.connections.get(record.key) !== record || record.enabled === false)) {
+        return { ok: false, message: '连接已变更，请重新读取工具' };
+      }
+      records.forEach((record, index) => {
+        if (state.connections.get(record.key) === record && record.enabled !== false) {
+          const at = Date.now();
+          state.toolViews.set(record.key, { record, server: servers[index], at });
+          const prior = discoveryPlans.get(record.key);
+          discoveryPlans.set(record.key, { record, ...nextDiscovery(prior?.record === record ? prior : null, servers[index], at) });
+        }
+      });
       const totalTools = servers.reduce((sum, s) => sum + (s.tools?.length || 0), 0);
       const availableServers = servers.filter((server) => server.ok).length;
       const unknownServers = servers.filter((server) => server.unknown).length;
@@ -2982,7 +3148,57 @@ export async function apply(ctx, config) {
   hostGovernance.refresh();
   hostScopes.refresh();
 
-  const observableApi = observeStatusEvents(api, statusEvents);
+  // One background pass at a time; UI event refreshes read snapshots, never tools/list.
+  let discoveryDisposed = false;
+  let discoveryRunning = false;
+  let discoveryPending = false;
+  let discoveryTimer = null;
+  async function discoverTools() {
+    if (discoveryDisposed || discoveryRunning) return;
+    discoveryRunning = true;
+    discoveryPending = false;
+    try {
+      const records = [...state.connections.values()].filter((record) => {
+        const plan = discoveryPlans.get(record.key);
+        return record.enabled !== false && discoveryDue(plan?.record === record ? plan : null);
+      });
+      let cursor = 0;
+      await Promise.all(Array.from({ length: Math.min(2, records.length) }, async () => {
+        while (cursor < records.length && !discoveryDisposed) {
+          const record = records[cursor++];
+          if (state.connections.get(record.key) !== record || record.enabled === false) continue;
+          await api.toolsList(record.connectorId, undefined, false, record.key).catch(() => {});
+          if (!discoveryDisposed) statusEvents.publish('tools');
+        }
+      }));
+    } finally {
+      discoveryRunning = false;
+      if (discoveryPending) scheduleDiscovery();
+    }
+  }
+  function scheduleDiscovery() {
+    if (discoveryDisposed) return;
+    discoveryPending = true;
+    if (discoveryRunning || discoveryTimer) return;
+    discoveryTimer = setTimeout(() => { discoveryTimer = null; void discoverTools(); }, 100);
+    discoveryTimer.unref?.();
+  }
+  const discoveryMutations = new Set(['connect', 'configure', 'importJson', 'installFromUrl', 'reconfigureConnection', 'setEnabled', 'restoreSnapshot', 'migrateLegacy']);
+  const discoveryApi = new Proxy(api, { get(target, property) {
+    const value = target[property];
+    if (!discoveryMutations.has(property)) return value;
+    return async (...args) => {
+      const result = await value.apply(target, args);
+      if (result?.ok) scheduleDiscovery();
+      return result;
+    };
+  } });
+  const observableApi = observeStatusEvents(discoveryApi, statusEvents);
+  scheduleDiscovery();
+  const discoveryInterval = setInterval(() => {
+    if (statusEvents.clients.size > 0) scheduleDiscovery();
+  }, 30_000);
+  discoveryInterval.unref?.();
   const disposeTools = registerTools(ctx, observableApi);
 
   /* ───────────────────────── web 半区（图形化市场）──────────────────────── */
@@ -3000,6 +3216,9 @@ export async function apply(ctx, config) {
   }
 
   ctx.effect(() => () => {
+    discoveryDisposed = true;
+    clearTimeout(discoveryTimer);
+    clearInterval(discoveryInterval);
     disposeTools();
     disposeWeb?.();
     hostGovernance.dispose();

package/lib/mcp-http.js

@@ -7,17 +7,19 @@
  */
 import { MCP_PROTOCOL_VERSION } from './constants.js';
 import { authHeaders } from './mcp-provision.js';
+import { parseRetryAfter } from './discovery-policy.js';
 
 const MAX_RESPONSE_BYTES = 2 * 1024 * 1024;
 const MAX_TOOL_PAGES = 100;
 const MAX_TOOLS = 10_000;
 
 export class McpHttpError extends Error {
-  constructor(message, { kind = 'protocol', status } = {}) {
+  constructor(message, { kind = 'protocol', status, retryAfterMs } = {}) {
     super(message);
     this.name = 'McpHttpError';
     this.kind = kind;
     this.status = status;
+    this.retryAfterMs = retryAfterMs;
   }
 }
 
@@ -64,7 +66,7 @@ function responseError(response, payload, text) {
     return new McpHttpError(`凭据无效、已过期或权限不足（HTTP ${response.status}）`, { kind: 'auth', status: response.status });
   }
   if (response.status === 429) {
-    return new McpHttpError('服务请求过于频繁（HTTP 429），请稍后重试', { kind: 'rate-limit', status: response.status });
+    return new McpHttpError('服务请求过于频繁（HTTP 429），请稍后重试', { kind: 'rate-limit', status: response.status, retryAfterMs: parseRetryAfter(response.headers.get('retry-after')) });
   }
   const suffix = rawMessage ? `：${rawMessage}` : '';
   return new McpHttpError(`MCP 请求失败（HTTP ${response.status}）${suffix}`, { kind: 'http', status: response.status });

package/lib/mcp-validation.js

@@ -4,6 +4,7 @@
  */
 import { MCP_PROTOCOL_VERSION } from './constants.js';
 import { authHeaders } from './mcp-provision.js';
+import { parseRetryAfter } from './discovery-policy.js';
 
 const MAX_RESPONSE_BYTES = 2 * 1024 * 1024;
 
@@ -142,7 +143,7 @@ export async function validateConnectionRecord(record, { timeoutMs = 15_000, fet
       return failed(record, 'auth', `Key/Token 无效、已过期或当前账号没有该 Server 权限（HTTP ${response.status}）`, { httpStatus: response.status });
     }
     if (response.status === 429) {
-      return failed(record, 'rate-limit', '服务请求过于频繁（HTTP 429），请稍后重试', { httpStatus: response.status });
+      return failed(record, 'rate-limit', '服务请求过于频繁（HTTP 429），请稍后重试', { httpStatus: response.status, retryAfterMs: parseRetryAfter(response.headers.get('retry-after')) });
     }
     if (!response.ok) {
       const message = response.status >= 500

package/lib/status-events.js

@@ -111,7 +111,7 @@ export function observeStatusEvents(api, eventHub, eventTypes = DEFAULT_EVENT_TY
         try {
           return await Reflect.apply(value, target, args);
         } finally {
-          eventHub.publish(eventType);
+          if (!(property === 'toolsList' && args[2] === true)) eventHub.publish(eventType);
         }
       };
     },

package/lib/tool-catalog-cache.js

@@ -23,7 +23,7 @@ function truncateUtf8(value, maxBytes) {
   return output;
 }
 
-function sanitizeSchemaValue(value, state, depth = 0) {
+function sanitizeSchemaValue(value, state, depth = 0, propertyMap = false) {
   if (state.nodes >= 2_048 || depth > 10) {
     state.truncated = true;
     return undefined;
@@ -47,12 +47,13 @@ function sanitizeSchemaValue(value, state, depth = 0) {
   const entries = Object.entries(value);
   if (entries.length > 128) state.truncated = true;
   for (const [rawKey, rawValue] of entries.slice(0, 128)) {
-    if (OMITTED_SCHEMA_KEYS.has(rawKey) || UNSAFE_KEYS.has(rawKey)) {
+    if ((!propertyMap && OMITTED_SCHEMA_KEYS.has(rawKey)) || UNSAFE_KEYS.has(rawKey)) {
       if (OMITTED_SCHEMA_KEYS.has(rawKey)) state.truncated = true;
       continue;
     }
     const key = truncateUtf8(rawKey, 256);
-    const child = sanitizeSchemaValue(rawValue, state, depth + 1);
+    const child = sanitizeSchemaValue(rawValue, state, depth + 1,
+      !propertyMap && ['properties', 'patternProperties', '$defs', 'definitions', 'dependentSchemas'].includes(rawKey));
     if (key && child !== undefined) output[key] = child;
   }
   return output;
@@ -166,14 +167,19 @@ function validLimit(limit) {
 }
 
 export function searchToolCatalog(entries, { query, connectorId, limit = 20 } = {}, now = Date.now(), ttlMs = TOOL_CACHE_TTL_MS) {
+  if (!normalizeToolSearchText(query)) throw new Error('工具搜索关键词不能为空');
+  return browseToolCatalog(entries, { query, connectorId, limit }, now, ttlMs).items;
+}
+
+export function browseToolCatalog(entries, { query, connectorId, serverName, limit = 20, offset = 0 } = {}, now = Date.now(), ttlMs = TOOL_CACHE_TTL_MS) {
   const normalizedQuery = normalizeToolSearchText(query);
-  if (!normalizedQuery) throw new Error('工具搜索关键词不能为空');
   const results = [];
   for (const entry of entries ?? []) {
     if (connectorId && entry.connectorId !== connectorId) continue;
+    if (serverName && entry.serverName !== serverName) continue;
     const cache = toolCatalogCacheView(entry, now, ttlMs);
     for (const tool of entry.tools ?? []) {
-      const score = toolSearchScore(tool, normalizedQuery);
+      const score = normalizedQuery ? toolSearchScore(tool, normalizedQuery) : 0;
       if (score < 0) continue;
       results.push({
         connectorId: entry.connectorId,
@@ -190,12 +196,11 @@ export function searchToolCatalog(entries, { query, connectorId, limit = 20 } =
       });
     }
   }
-  return results
-    .sort((left, right) => right.score - left.score
+  results.sort((left, right) => right.score - left.score
       || left.name.localeCompare(right.name)
-      || left.serverName.localeCompare(right.serverName))
-    .slice(0, validLimit(limit))
-    .map(({ score, ...item }) => item);
+      || left.serverName.localeCompare(right.serverName) || left.connectionKey.localeCompare(right.connectionKey));
+  const start = Number.isFinite(Number(offset)) ? Math.max(0, Math.trunc(Number(offset))) : 0;
+  return { total: results.length, items: results.slice(start, start + validLimit(limit)).map(({ score, ...item }) => item) };
 }
 
 export function findToolDetails(entries, { toolName, connectorId, serverName } = {}, now = Date.now(), ttlMs = TOOL_CACHE_TTL_MS) {

package/lib/tools.js

@@ -607,6 +607,7 @@ export function registerTools(ctx, api) {
       properties: {
         connectorId: { type: 'string', description: '连接器 id（来自 mcp_connector_catalog）' },
         workspaceId: { type: 'string', description: '可选；只加载在该 Workspace 可见的已连接 Server' },
+        connectionKey: { type: 'string', description: '可选；来自 status 的连接 key，限定手动、JSON 或目录安装的单条连接' },
       },
       required: ['connectorId'],
       additionalProperties: false,
@@ -614,7 +615,7 @@ export function registerTools(ctx, api) {
     output: toolsListOutput,
     timeoutMs: 30_000,
     async execute(args) {
-      return api.toolsList(args.connectorId, args.workspaceId);
+      return api.toolsList(args.connectorId, args.workspaceId, false, args.connectionKey);
     },
   });
 
@@ -640,6 +641,7 @@ export function registerTools(ctx, api) {
       type: 'object',
       properties: {
         query: { type: 'string', description: '工具名称、标题或描述关键词' },
+        connectionKey: { type: 'string', description: '可选；限定单条连接 key' },
         connectorId: { type: 'string', description: '可选；限定连接器 id' },
         workspaceId: { type: 'string', description: '可选；仅搜索该 Workspace 可见的连接' },
         limit: { type: 'number', minimum: 1, maximum: 100, description: '最多返回数量，默认 20' },
@@ -672,6 +674,7 @@ export function registerTools(ctx, api) {
       type: 'object',
       properties: {
         toolName: { type: 'string', description: '精确工具名（来自 mcp_connector_tool_search）' },
+        connectionKey: { type: 'string', description: '可选；限定单条连接 key' },
         connectorId: { type: 'string', description: '可选；用于消除同名歧义' },
         serverName: { type: 'string', description: '可选；用于消除同名歧义' },
         workspaceId: { type: 'string', description: '可选；仅查看该 Workspace 可见的连接' },

package/lib/web.js

@@ -48,8 +48,11 @@ const API_WHITELIST = new Map([
   ['disconnect', (api, p) => api.disconnect(p?.key)],
   ['setEnabled', (api, p) => api.setEnabled(p?.key, p?.enabled !== false)],
   ['refreshCatalog', (api) => api.refreshCatalog()],
-  ['toolsList', (api, p) => api.toolsList(p?.connectorId, p?.workspaceId)],
+  ['toolsList', (api, p) => api.toolsList(p?.connectorId, p?.workspaceId, p?.cachedOnly === true, p?.connectionKey)],
   ['toolSearch', (api, p) => api.toolSearch(p ?? {})],
+  ['toolExplorer', (api, p) => api.toolExplorer(p ?? {})],
+  ['toolExplorerDetail', (api, p) => api.toolExplorerDetail(p ?? {})],
+  ['toolExplorerAction', (api, p) => api.toolExplorerAction(p ?? {})],
   ['toolDetail', (api, p) => api.toolDetail(p ?? {})],
 ]);
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "dsh-mcp-connector",
-  "version": "0.2.43",
+  "version": "0.2.45",
   "description": "DeepSeek Harness MCP Connector and MCP Server marketplace with over one hundred MCP connectors, continuously updated. Discover, authorize, and manage connections in one place; supports OAuth 2.0 PKCE, API keys, stdio/HTTP, mcpServers JSON import, and tool and prompt discovery. Maintained by Qichacha/QCC.",
   "type": "module",
   "main": "lib/index.js",
@@ -41,7 +41,7 @@
   ],
   "scripts": {
     "test": "node --test",
-    "lint": "node --check lib/index.js && node --check lib/web.js && node --check lib/client.js && node --check lib/settings.js && node --check lib/version-status.js && node --check lib/schema.js && node --check lib/catalog.js && node --check lib/prompts.js && node --check lib/probe.js && node --check lib/diagnostics.js && node --check lib/connection-backup.js && node --check lib/connection-editor.js && node --check lib/connection-scopes.js && node --check lib/governance.js && node --check lib/tool-catalog-cache.js && node --check lib/status-events.js && node --check lib/mcp-validation.js && node --check lib/mcp-http.js && node --check lib/migration.js && node --check lib/stores.js && node --check lib/grant-journal.js && node --check lib/oauth.js && node --check lib/grant-lifecycle.js && node --check lib/callback-server.js && node --check lib/mcp-provision.js && node --check lib/util.js && node --check lib/constants.js && node --check lib/tools.js && node --check lib/connectors/oauth-connector.js && node --check lib/connectors/manual-connector.js && node --check lib/connectors/json-connector.js && node --check scripts/probe-connector.mjs && node --check scripts/build-registry.mjs && node --check scripts/ui-harness.mjs && node --check scripts/check-market-registration.mjs && node --check scripts/check-distribution-sync.mjs && node --check scripts/check-readme-version.mjs && node --check scripts/check-marketing-metadata.mjs && node --check scripts/check-storefront-screenshots.mjs && node --check scripts/sync-registry-stats.mjs && node --check scripts/verify-pack.mjs",
+    "lint": "node --check lib/discovery-policy.js && node --check lib/index.js && node --check lib/web.js && node --check lib/client.js && node --check lib/settings.js && node --check lib/version-status.js && node --check lib/schema.js && node --check lib/catalog.js && node --check lib/prompts.js && node --check lib/probe.js && node --check lib/diagnostics.js && node --check lib/connection-backup.js && node --check lib/connection-editor.js && node --check lib/connection-scopes.js && node --check lib/governance.js && node --check lib/tool-catalog-cache.js && node --check lib/status-events.js && node --check lib/mcp-validation.js && node --check lib/mcp-http.js && node --check lib/migration.js && node --check lib/stores.js && node --check lib/grant-journal.js && node --check lib/oauth.js && node --check lib/grant-lifecycle.js && node --check lib/callback-server.js && node --check lib/mcp-provision.js && node --check lib/util.js && node --check lib/constants.js && node --check lib/tools.js && node --check lib/connectors/oauth-connector.js && node --check lib/connectors/manual-connector.js && node --check lib/connectors/json-connector.js && node --check scripts/probe-connector.mjs && node --check scripts/build-registry.mjs && node --check scripts/ui-harness.mjs && node --check scripts/check-market-registration.mjs && node --check scripts/check-distribution-sync.mjs && node --check scripts/check-readme-version.mjs && node --check scripts/check-marketing-metadata.mjs && node --check scripts/check-storefront-screenshots.mjs && node --check scripts/sync-registry-stats.mjs && node --check scripts/verify-pack.mjs",
     "registry:build": "node scripts/build-registry.mjs",
     "registry:validate": "node scripts/probe-connector.mjs catalog/catalog.json --validate-only",
     "dev:ui": "node scripts/ui-harness.mjs",

package/scripts/ui-harness.mjs

@@ -8,6 +8,7 @@ import { normalizeConnectorDescriptor } from '../lib/schema.js';
 import { auditDescriptor, auditRawDescriptor, mergeCatalog } from '../lib/catalog.js';
 import { normalizeGovernanceMutation, publicToolName, resolveGovernancePolicy } from '../lib/governance.js';
 import { ConnectionScopeService, bindingForConnection, scopeLabel } from '../lib/connection-scopes.js';
+import { browseToolCatalog, createToolCatalogRecord } from '../lib/tool-catalog-cache.js';
 
 const root = join(dirname(fileURLToPath(import.meta.url)), '..');
 const packageJson = JSON.parse(await readFile(join(root, 'package.json'), 'utf8'));
@@ -43,6 +44,8 @@ const bundledAssets = new Map([
   ['wind-logo.png', 'image/png'],
 ]);
 const eventClients = new Set();
+const mockExplorerRecovered = new Set();
+const mockObservedAt = Date.now();
 let eventSequence = 0;
 
 function publishStatus(type) {
@@ -359,6 +362,28 @@ const server = createServer(async (req, res) => {
       json(res, { ok: false, message: `Mock 作用域回滚失败: ${error.message}` }); return;
     }
   }
+  if (method === 'toolExplorer') {
+    const connections = catalog.filter((item) => connected.has(item.id)).flatMap((item) => item.servers.map((server, index) => {
+      const key = `${item.id}:${server.serverKey}`;
+      const failed = index === 1 && !mockExplorerRecovered.has(key);
+      return { connectionKey: key, connectorId: item.id, connectorName: item.name, connectionName: `${item.name} · ${server.serverKey}`,
+        serverName: server.serverName, status: failed ? 'failed' : 'success', checkedAt: mockObservedAt, observedAt: mockObservedAt,
+        toolCount: 125, diagnostic: failed ? { stageLabel: '网络与传输', message: '模拟连接超时（非真实服务故障）', action: '检查网络后重新发现工具' } : null };
+    }));
+    const selectedConnections = connections.filter((c) => (!params.connectionKey || c.connectionKey === params.connectionKey)
+      && (!params.serverName || c.serverName === params.serverName) && (!params.status || c.status === params.status));
+    const entries = selectedConnections.map((c) => createToolCatalogRecord({ key: c.connectionKey, connectorId: c.connectorId, serverName: c.serverName, transport: 'stdio' },
+      Array.from({ length: 125 }, (_, i) => ({ name: `mock_tool_${String(i + 1).padStart(3, '0')}`, title: `Mock 工具 ${i + 1}`, description: '本机无凭据测试数据，不执行真实工具。' })), mockObservedAt));
+    const result = browseToolCatalog(entries, params);
+    json(res, { ok: true, message: 'Mock 工具浏览', detail: { ...result,
+      items: result.items.map((item) => ({ ...item, connection: connections.find((c) => c.connectionKey === item.connectionKey) })),
+      connections, selectedConnections, scopeLabel: '本机无凭据模拟连接' } }); return;
+  }
+  if (method === 'toolExplorerAction') {
+    mockExplorerRecovered.add(params.connectionKey);
+    publishStatus('tools');
+    json(res, { ok: true, message: '模拟操作完成：未访问真实服务' }); return;
+  }
   if (method === 'toolsList') {
     const connector = catalog.find((item) => item.id === params.connectorId);
     const server = connector?.servers?.[0] ?? { serverKey: 'mock', serverName: 'mock-server' };
@@ -430,14 +455,17 @@ const server = createServer(async (req, res) => {
     }).filter((tool) => `${tool.name} ${tool.title} ${tool.description}`.toLowerCase().includes(query)).slice(0, params.limit || 20);
     json(res, { ok: true, message: `Mock 找到 ${items.length} 个工具`, detail: { items, source: 'last-success-cache', discoveryOnly: true } }); return;
   }
-  if (method === 'toolDetail') {
+  if (method === 'toolDetail' || method === 'toolExplorerDetail') {
     json(res, { ok: true, message: `Mock 工具详情：${params.toolName}`, detail: { tool: {
       connectorId: params.connectorId,
       serverName: params.serverName,
       name: params.toolName,
       title: params.toolName,
       description: '本地无凭据 UI 验收数据；不会执行真实 MCP 工具。',
-      inputSchema: { type: 'object', properties: { query: { type: 'string', description: '公开检索词' } }, required: ['query'] },
+      inputSchema: { type: 'object', properties: { query: { type: 'string', description: '公开检索词', minLength: 1 },
+        mode: { type: 'string', enum: ['basic', 'full'], description: '返回详细程度' },
+        filters: { type: 'object', properties: { regions: { type: 'array', items: { type: 'string' } } } },
+        target: { oneOf: [{ type: 'string' }, { type: 'number' }] } }, required: ['query'] },
       observedAt: Date.now(),
       stale: false,
       schemaTruncated: false,

package/ui/index.html

@@ -331,6 +331,16 @@
   .tool-deprecated { color: var(--warn); background: var(--warn-bg); border-radius: 999px; padding: 1px 6px; font-size: 10px; line-height: 1.5; flex: 0 0 auto; }
   .tool-description { color: var(--text-2); font-size: 12px; line-height: 1.55; margin-top: 4px; white-space: pre-wrap; overflow-wrap: anywhere; }
   .tool-description.empty { color: var(--muted); font-style: italic; }
+  .explorer-filters { display:flex; flex-wrap:wrap; gap:10px; align-items:end; }
+  .explorer-filters label { display:flex; flex:1 1 150px; flex-direction:column; gap:5px; font-size:12px; }
+  .explorer-filters select { width:100%; min-width:0; padding:8px; border:1px solid var(--line); border-radius:8px; background:var(--bg); color:var(--text); }
+  .explorer-card { border:1px solid var(--line); padding:14px; border-radius:10px; margin:10px 0; overflow-wrap:anywhere; }
+  .explorer-card p { margin:8px 0; white-space:pre-wrap; }
+  .parameter-scroll { overflow-x:auto; }
+  .parameter-table { width:100%; border-collapse:collapse; font-size:12px; }
+  .parameter-table th, .parameter-table td { border-bottom:1px solid var(--line); padding:8px; text-align:left; vertical-align:top; overflow-wrap:anywhere; }
+  .parameter-table th { white-space:nowrap; }
+  .parameter-table details { margin-top:6px; }
   .tools-loading, .tools-error { font-size: 13px; color: var(--muted); padding: 8px; }
   .tools-error { color: var(--bad); }
   .tools-empty { color: var(--muted); font-size: 12px; text-align: center; padding: 24px 8px; }
@@ -429,6 +439,7 @@
     <div class="tabs" id="tabs">
       <button data-view="market" class="active">市场 <span class="tab-count" id="market-tab-count"></span></button>
       <button data-view="installed">已安装 <span class="tab-count" id="installed-tab-count"></span></button>
+      <button data-view="tools">工具</button>
     </div>
     <div class="header-spacer"></div>
     <div class="search-box">
@@ -546,6 +557,13 @@
   let view = 'market';
   let marketItems = {};
   let searchQuery = '';
+  let explorerFilter = { connectionKey: '', serverName: '', status: '' };
+  let explorerOffset = 0;
+  let explorerSequence = 0;
+  let explorerDetailSequence = 0;
+  let explorerData = null;
+  let searchTimer = null;
+  const explorerBusy = new Set();
   let marketCategory = '';
   const PROMPT_PAGE_SIZE = 4;
   let detailPrompts = [];
@@ -649,7 +667,14 @@
       currentWorkspace = workspace && typeof workspace.workspaceId === 'string'
         ? { workspaceId: workspace.workspaceId, title: String(workspace.title || workspace.workspaceId) }
         : null;
-      if ((currentWorkspace?.workspaceId ?? null) !== previousWorkspaceId) refresh();
+      if ((currentWorkspace?.workspaceId ?? null) !== previousWorkspaceId) {
+        explorerSequence++; explorerDetailSequence++;
+        explorerData = null; explorerOffset = 0;
+        explorerFilter = { connectionKey: '', serverName: '', status: '' };
+        closeModal(); closeDetail();
+        if (view === 'tools') main.innerHTML = '';
+        refresh();
+      }
       return;
     }
     if (event.data?.type === PROMPT_RESULT_TYPE) {
@@ -782,7 +807,7 @@
   }
 
   function policySelect(scope, current, serverName = '', toolName = '', publicName = '', label = '') {
-    if (!detailConnector?.connected?.length) return '';
+    if (!detailConnector?.connected?.length || detailConnector.connectionKey) return '';
     return `<select class="policy-select" data-policy-scope="${esc(scope)}" data-current-effect="${esc(current || 'inherit')}" data-server-name="${esc(serverName)}" data-tool-name="${esc(toolName)}" data-public-name="${esc(publicName)}" aria-label="${esc(label || `${scope} 策略`)}">${policyOptions(current)}</select>`;
   }
 
@@ -799,7 +824,7 @@
 
   function syncGovernanceBar() {
     const bar = $('#governance-bar');
-    const connected = detailConnector?.connected?.length > 0;
+    const connected = detailConnector?.connected?.length > 0 && !detailConnector.connectionKey;
     bar.hidden = !connected;
     if (!connected) return;
     const connectionEffect = detailGovernance?.connectionPolicy || 'inherit';
@@ -861,8 +886,34 @@
     if (result.ok && detailConnector) await window.__mcp.showDetail(detailConnector.id);
   }
 
+  function normalizeToolSearchText(value) {
+    return String(value ?? '').normalize('NFKC')
+      .replace(/([\p{Script=Han}])([A-Za-z0-9])/gu, '$1 $2')
+      .replace(/([A-Za-z0-9])([\p{Script=Han}])/gu, '$1 $2')
+      .toLocaleLowerCase('zh-CN').replace(/[^\p{Letter}\p{Number}]+/gu, ' ').trim().replace(/\s+/g, ' ');
+  }
+
+  function toolSearchScore(tool, query) {
+    const terms = query.split(' ').filter(Boolean);
+    const fields = [tool.name, tool.title, tool.description].map(normalizeToolSearchText);
+    const compactQuery = query.replace(/ /g, '');
+    const compactFields = fields.map((field) => field.replace(/ /g, ''));
+    const fieldIndex = fields.findIndex((field, index) => (
+      terms.every((term) => field.includes(term)) || compactFields[index].includes(compactQuery)
+    ));
+    if (fieldIndex < 0) return -1;
+    const field = fields[fieldIndex];
+    const compact = compactFields[fieldIndex];
+    let score = fieldIndex === 0 ? 300 : fieldIndex === 1 ? 180 : 80;
+    if (field === query || compact === compactQuery) score += 1_000;
+    else if (field.startsWith(query) || compact.startsWith(compactQuery)) score += 500;
+    else if (field.includes(query) || compact.includes(compactQuery)) score += 250;
+    score -= Math.min(field.length, 200) / 1_000;
+    return score;
+  }
+
   function renderTools() {
-    const query = $('#tools-search').value.trim().toLowerCase();
+    const query = normalizeToolSearchText($('#tools-search').value);
     if (detailToolServers.length === 0) {
       updateToolsSummary();
       $('#detail-tools').innerHTML = '<div class="tools-empty">暂无可用工具</div>';
@@ -871,17 +922,22 @@
     let matchedTools = 0;
     let renderedTools = 0;
     let remaining = toolRenderLimit;
-    const groups = detailToolServers.map((server) => {
+    const rankedServers = query ? [...detailToolServers].sort((a, b) =>
+      Math.max(-1, ...(b.tools || []).map((tool) => toolSearchScore(tool, query)))
+      - Math.max(-1, ...(a.tools || []).map((tool) => toolSearchScore(tool, query)))) : detailToolServers;
+    const groups = rankedServers.map((server) => {
       const label = server.serverName || server.serverKey || 'MCP Server';
       const serverSelect = policySelect('server', server.policy?.configuredEffect, server.serverName, '', '', `${label} Server 策略`);
       if (!server.ok && !server.cached) {
         if (query) return '';
-        return `<div class="tools-server"><div class="tools-server-header"><span class="tools-server-copy">${esc(label)} <span class="count">· 加载失败</span></span>${serverSelect}</div><div class="tools-error">${esc(server.error || '未知错误')}</div></div>`;
+        return `<div class="tools-server"><div class="tools-server-header"><span class="tools-server-copy">${esc(label)} <span class="count">· ${server.pending ? '正在发现' : '加载失败'}</span></span>${serverSelect}</div><div class="tools-error">${esc(server.error || '未知错误')}</div></div>`;
       }
       const matched = (server.tools || []).filter((tool) => {
         if (!query) return true;
-        return `${tool.name || ''}\n${tool.title || ''}\n${tool.description || ''}`.toLowerCase().includes(query);
-      }).sort((left, right) => Number(isDeprecatedTool(left)) - Number(isDeprecatedTool(right)));
+        return toolSearchScore(tool, query) >= 0;
+      }).sort((left, right) => query
+        ? toolSearchScore(right, query) - toolSearchScore(left, query) || left.name.localeCompare(right.name)
+        : Number(isDeprecatedTool(left)) - Number(isDeprecatedTool(right)));
       if (query && matched.length === 0) return '';
       matchedTools += matched.length;
       const tools = matched.slice(0, Math.max(0, remaining));
@@ -923,6 +979,7 @@
   async function openToolDetail(serverName, toolName) {
     if (!detailConnector || !toolName) return;
     const result = await call('toolDetail', {
+      connectionKey: detailConnector.connectionKey,
       connectorId: detailConnector.id,
       serverName,
       toolName,
@@ -933,15 +990,42 @@
       return;
     }
     const tool = result.detail?.tool || {};
+    showToolParameters(tool, toolName, serverName);
+  }
+
+  function schemaSummary(schema, depth = 0, budget = { remaining: 150 }) {
+    if (depth > 5 || --budget.remaining < 0) return '<p class="hint">结构较大，请查看原始 Schema。</p>';
+    if (typeof schema === 'boolean') return `<p>${schema ? '允许任意输入' : '不允许任何输入'}</p>`;
+    if (!schema || typeof schema !== 'object') return '<p class="hint">暂无参数定义。</p>';
+    const complex = ['$ref', 'oneOf', 'anyOf', 'allOf', 'if', 'then', 'else', 'not'].some((key) => key in schema);
+    const required = new Set(Array.isArray(schema.required) ? schema.required : []);
+    const allEntries = Object.entries(schema.properties || {});
+    const entries = allEntries.slice(0, 100);
+    const rows = entries.map(([key, raw]) => {
+      if (--budget.remaining < 0) return '';
+      const field = raw && typeof raw === 'object' ? raw : {};
+      const type = typeof raw === 'boolean' ? (raw ? '任意类型' : '禁止输入') : Array.isArray(field.type) ? field.type.join(' / ') : field.type || (field.properties ? 'object' : '未声明');
+      const constraints = ['enum', 'minimum', 'maximum', 'exclusiveMinimum', 'exclusiveMaximum', 'minLength', 'maxLength', 'minItems', 'maxItems', 'pattern'].filter((name) => field[name] !== undefined)
+        .map((name) => `${name}: ${JSON.stringify(field[name])}`).join('；');
+      const nested = field.properties || field.items || ['$ref', 'oneOf', 'anyOf', 'allOf'].some((name) => name in field);
+      return `<tr><td><code>${esc(key)}</code></td><td>${esc(type)}</td><td>${required.has(key) ? '必填' : '可选'}</td><td>${esc(field.description || '暂无说明')}${constraints ? `<div class="hint">${esc(constraints)}</div>` : ''}${nested ? `<details><summary>展开结构</summary>${schemaSummary(field, depth + 1, budget)}</details>` : ''}</td></tr>`;
+    }).join('');
+    const items = (allEntries.length > 100 || budget.remaining < 0 ? '<p class="hint">摘要已截断，请查看原始 Schema 中的其余字段。</p>' : '') + (schema.items !== undefined ? `<details><summary>数组元素</summary>${schemaSummary(schema.items, depth + 1, budget)}</details>` : '');
+    return `${complex ? '<p class="hint">包含引用或组合约束，摘要不代表完整规则，请同时查看原始 Schema。</p>' : ''}${rows ? `<div class="parameter-scroll"><table class="parameter-table"><thead><tr><th>参数</th><th>类型</th><th>要求</th><th>说明与约束</th></tr></thead><tbody>${rows}</tbody></table></div>` : `<p class="hint">类型：${esc(Array.isArray(schema.type) ? schema.type.join(' / ') : schema.type || '未声明')}；无可展开的具名参数，请查看原始 Schema。</p>`}${items}`;
+  }
+
+  function showToolParameters(tool, toolName, serverName) {
     const observed = tool.observedAt ? new Date(tool.observedAt).toLocaleString('zh-CN', { hour12: false }) : '未知';
     const schema = tool.inputSchema ? JSON.stringify(tool.inputSchema, null, 2) : '未缓存输入参数 schema';
     openModal(`工具参数 · ${tool.name || toolName}`, `
       <p class="hint">${esc(tool.serverName || serverName)} · 最后成功 ${esc(observed)}${tool.stale ? ' · 缓存已超过 24 小时' : ''}${tool.schemaTruncated ? ' · schema 已安全裁剪' : ''}</p>
       <p>${esc(tool.description || '暂无描述')}</p>
-      <pre class="tool-schema">${esc(schema)}</pre>
+      ${schemaSummary(tool.inputSchema)}
+      <details><summary>原始 Schema（安全缓存）</summary><pre class="tool-schema">${esc(schema)}</pre></details>
       <div class="m-actions"><button class="btn ghost" type="button" onclick="window.__mcp.closeModal()">关闭</button></div>`);
   }
   function closeModal() {
+    explorerDetailSequence++;
     $('#modalMask').classList.remove('show');
     $('#modalMask').setAttribute('aria-hidden', 'true');
     pendingPrompt = null;
@@ -1121,6 +1205,68 @@
     return `<button class="btn ghost" type="button" onclick="event.stopPropagation();window.__mcp.showDetail('${id}')">${t('details')}</button><button class="btn" type="button" onclick="event.stopPropagation();window.__mcp.openConfig('${id}')">${t('configure')}</button>`;
   }
 
+  const EXPLORER_STATUS = { pending: '尚未发现', unknown: 'Host 状态未知', success: '最近发现成功', failed: '最近发现失败' };
+  const formatObserved = (value) => value ? new Date(value).toLocaleString('zh-CN', { hour12: false }) : '尚无记录';
+
+  async function loadToolExplorer() {
+    const sequence = ++explorerSequence;
+    const workspaceId = currentWorkspace?.workspaceId;
+    syncMarketNav();
+    if (!$('#tool-explorer')) {
+      main.innerHTML = `<section id="tool-explorer"><p class="hint">搜索当前范围内已启用连接的工具缓存；不会执行工具。最近发现成功不代表每次调用均可成功。</p><div class="explorer-filters"><label>连接<select id="explorer-connection" aria-label="按连接筛选"></select></label><label>服务<select id="explorer-server" aria-label="按服务筛选"></select></label><label>发现状态<select id="explorer-status" aria-label="按发现状态筛选"><option value="">全部状态</option>${Object.entries(EXPLORER_STATUS).map(([key, label]) => `<option value="${key}">${label}</option>`).join('')}</select></label><button class="btn ghost" data-explorer-clear>清除筛选</button></div><p id="explorer-summary" role="status">正在读取缓存…</p><div id="explorer-connections"></div><div id="explorer-results"></div><div id="explorer-pages" class="m-actions"></div></section>`;
+    }
+    const response = await call('toolExplorer', { ...workspaceParams(), ...explorerFilter, query: searchQuery, offset: explorerOffset, limit: 20 });
+    if (sequence !== explorerSequence || view !== 'tools' || workspaceId !== currentWorkspace?.workspaceId) return;
+    if (!response.ok) { $('#explorer-summary').textContent = response.message; return; }
+    explorerData = response.detail;
+    const { connections = [], selectedConnections = [], items = [], total = 0 } = explorerData;
+    if (explorerOffset >= total && explorerOffset > 0) { explorerOffset = Math.max(0, Math.floor((total - 1) / 20) * 20); return loadToolExplorer(); }
+    $('#explorer-connection').innerHTML = '<option value="">全部连接</option>' + connections.map((c) => `<option value="${esc(c.connectionKey)}">${esc(c.connectionName)} · ${esc(c.serverName)}</option>`).join('');
+    const services = [...new Set(connections.filter((c) => !explorerFilter.connectionKey || c.connectionKey === explorerFilter.connectionKey).map((c) => c.serverName))];
+    $('#explorer-server').innerHTML = '<option value="">全部服务</option>' + services.map((name) => `<option value="${esc(name)}">${esc(name)}</option>`).join('');
+    $('#explorer-connection').value = explorerFilter.connectionKey;
+    $('#explorer-server').value = explorerFilter.serverName;
+    $('#explorer-status').value = explorerFilter.status;
+    $('#explorer-summary').textContent = `${explorerData.scopeLabel} · ${connections.length} 条连接 · 匹配 ${total} 个工具 · 显示 ${items.length} 个`;
+    $('#explorer-connections').innerHTML = `<details ${explorerFilter.connectionKey || !total ? 'open' : ''}><summary>连接状态与故障处理（${selectedConnections.length}）</summary>${selectedConnections.map((c) => `<div class="explorer-card"><strong>${esc(c.connectionName)}</strong><div>${esc(c.serverName)} · ${esc(EXPLORER_STATUS[c.status] || c.status)} · 缓存 ${c.toolCount} 个工具</div><div class="hint">最近发现：${esc(formatObserved(c.checkedAt))}；最后成功：${esc(formatObserved(c.observedAt))}${c.stale ? ' · 缓存超过 24 小时' : ''}${c.cacheTruncated ? ' · 缓存清单已截断' : ''}</div>${c.diagnostic ? `<div>${esc(c.diagnostic.stageLabel)}：${esc(c.diagnostic.message)}<br>建议：${esc(c.diagnostic.action)}</div>` : ''}${c.retryReason === 'auth' ? '<p>鉴权失败已暂停后台重试，请到已安装页更新凭据或重新授权。</p>' : c.nextDiscoveryAt ? `<p class="hint">下次后台发现不早于：${esc(formatObserved(c.nextDiscoveryAt))}（页面保持连接时）</p>` : ''}<div class="m-actions"><button class="btn ghost" data-explorer-action="discover" data-key="${esc(c.connectionKey)}" ${explorerBusy.has(c.connectionKey) ? 'disabled' : ''}>重新发现工具</button><button class="btn ghost" data-explorer-action="check" data-key="${esc(c.connectionKey)}" ${explorerBusy.has(c.connectionKey) ? 'disabled' : ''}>检查连接</button></div></div>`).join('') || '<p>当前筛选下没有连接。</p>'}</details>`;
+    $('#explorer-results').innerHTML = items.map((item, index) => `<article class="explorer-card"><strong>${esc(item.name)}</strong>${item.title !== item.name ? `<div>${esc(item.title)}</div>` : ''}<p>${esc(item.description || '暂无描述')}</p><div class="hint">来源：${esc(item.connection.connectorName)} / ${esc(item.connection.connectionName)} / ${esc(item.serverName)}<br>${esc(EXPLORER_STATUS[item.connection.status])} · 最后成功缓存 ${esc(formatObserved(item.observedAt))}${item.stale ? ' · 已超过 24 小时' : ''}</div><button class="btn ghost" data-explorer-detail="${index}">参数详情</button></article>`).join('') || `<p class="empty">${connections.length ? '没有匹配工具。请调整关键词或筛选；也可展开连接状态检查是否尚未发现或读取失败。' : '当前范围没有已启用连接。请先添加连接，或选择对应工作区。'}</p>`;
+    $('#explorer-pages').innerHTML = `<button class="btn ghost" data-explorer-page="prev" ${explorerOffset === 0 ? 'disabled' : ''}>上一页</button><span>${Math.floor(explorerOffset / 20) + 1} / ${Math.max(1, Math.ceil(total / 20))}</span><button class="btn ghost" data-explorer-page="next" ${explorerOffset + 20 >= total ? 'disabled' : ''}>下一页</button>`;
+  }
+
+  main.addEventListener('change', (event) => {
+    const fields = { 'explorer-connection': 'connectionKey', 'explorer-server': 'serverName', 'explorer-status': 'status' };
+    const field = fields[event.target.id];
+    if (!field) return;
+    explorerFilter[field] = event.target.value;
+    if (field === 'connectionKey') explorerFilter.serverName = '';
+    explorerOffset = 0; void loadToolExplorer();
+  });
+
+  main.addEventListener('click', async (event) => {
+    const button = event.target.closest('button');
+    if (!button || view !== 'tools') return;
+    if (button.hasAttribute('data-explorer-clear')) {
+      explorerFilter = { connectionKey: '', serverName: '', status: '' }; explorerOffset = 0; await loadToolExplorer();
+    } else if (button.dataset.explorerPage) {
+      explorerOffset = Math.max(0, explorerOffset + (button.dataset.explorerPage === 'next' ? 20 : -20)); await loadToolExplorer();
+    } else if (button.dataset.explorerDetail !== undefined) {
+      const item = explorerData?.items[Number(button.dataset.explorerDetail)];
+      if (!item) return;
+      const requestId = ++explorerDetailSequence;
+      const result = await call('toolExplorerDetail', { connectionKey: item.connectionKey, serverName: item.serverName, toolName: item.name, ...workspaceParams() });
+      if (requestId !== explorerDetailSequence || view !== 'tools') return;
+      if (result.ok) showToolParameters(result.detail.tool, item.name, item.serverName);
+      else showToast(result.message, false);
+    } else if (button.dataset.explorerAction) {
+      const key = button.dataset.key;
+      if (explorerBusy.has(key)) return;
+      explorerBusy.add(key); button.disabled = true;
+      const result = await call('toolExplorerAction', { connectionKey: key, action: button.dataset.explorerAction, ...workspaceParams() });
+      explorerBusy.delete(key); showToast(result.message, result.ok);
+      if (view === 'tools') await loadToolExplorer();
+    }
+  });
+
   async function loadInstalled() {
     syncMarketNav();
     main.innerHTML = '<div class="empty">加载中…</div>';
@@ -1166,6 +1312,7 @@
       </label>
       ${canEditConfiguration ? `<button class="btn ghost" type="button" onclick="window.__mcp.openEditor('${key}')">编辑配置</button>` : ''}
       ${canRename ? `<button class="btn ghost" type="button" onclick="window.__mcp.openRename('${key}')">重命名</button>` : ''}
+      ${enabled ? `<button class="btn ghost" type="button" onclick="window.__mcp.showConnectionTools('${key}')">工具</button>` : ''}
       <button class="btn ghost" type="button" onclick="window.__mcp.openScope('${key}')">范围</button>
       <button class="btn danger" onclick="window.__mcp.disconnect('${key}')">断开</button>
     </div>`;
@@ -1708,8 +1855,17 @@
       showToast(result.message, result.ok);
       await loadInstalled();
     },
-    async showDetail(connectorId) {
-      const d = marketItems[connectorId];
+    async showConnectionTools(key) {
+      const record = installedItems.find((item) => item.key === key);
+      if (!record) return;
+      await window.__mcp.showDetail(record.connectorId, {
+        id: record.connectorId, connectionKey: key, name: record.name, icon: '🔌',
+        authMode: record.authMode, connected: [record], connectionState: record.connectionState,
+        description: '本机连接的工具发现与参数详情；不会执行工具。',
+      });
+    },
+    async showDetail(connectorId, connectionDescriptor) {
+      const d = connectionDescriptor || marketItems[connectorId];
       if (!d) return;
       detailConnector = d;
       const incomplete = d.connected?.length > 0 && d.connectionComplete === false;
@@ -1738,6 +1894,8 @@
       syncGovernanceBar();
       setDetailOpen(true);
       $('#detail-disconnect-btn').style.display = d.connected?.length > 0 ? 'block' : 'none';
+      if (d.connectionKey) $('#detail-disconnect-btn').style.display = 'none';
+      $('#detail-try-btn').style.display = d.connectionKey ? 'none' : '';
       const needsCredential = ['bearer', 'api-key'].includes(d.authMode);
       $('#detail-try-btn').textContent = detailNeedsReconfigure
         ? detailFailureState === 'incomplete' ? (d.authMode === 'oauth2-pkce' ? t('upgradeOauth') : t('completeSetup')) : d.authMode === 'oauth2-pkce' && detailFailureState === 'reauth' ? '🔐 重新授权' : needsCredential && detailFailureState === 'reauth' ? t('reconfigureCredential') : '🔄 重新检查'
@@ -1749,7 +1907,7 @@
         return;
       }
       const [toolsResult, governanceResult] = await Promise.all([
-        call('toolsList', { connectorId, ...workspaceParams() }),
+        call('toolsList', { connectorId, connectionKey: d.connectionKey, ...workspaceParams() }),
         call('governance', {}),
       ]);
       if (loadId !== detailLoadId || !$('#detail-overlay').classList.contains('active')) return;
@@ -1951,13 +2109,53 @@
   });
   let statusEventSource = null;
   let statusRefreshTimer = null;
+  let statusRefreshRunning = false;
+  let statusRefreshPending = false;
+
+  async function refreshOpenToolDetail() {
+    if (!detailConnector || !$('#detail-overlay').classList.contains('active')) return;
+    const id = detailLoadId;
+    const result = await call('toolsList', { connectorId: detailConnector.id, connectionKey: detailConnector.connectionKey, ...workspaceParams(), cachedOnly: true });
+    if (id !== detailLoadId || !$('#detail-overlay').classList.contains('active')) return;
+    if (!result.detail?.servers) {
+      detailToolServers = [];
+      renderTools();
+      $('#tools-summary').textContent = result.message || '连接当前不可用';
+      return;
+    }
+    if (result.detail?.servers) {
+      detailToolServers = result.detail.servers;
+      renderTools();
+      const pending = detailToolServers.some((server) => server.pending);
+      const unknown = detailToolServers.some((server) => server.unknown);
+      const available = detailToolServers.filter((server) => server.ok).length;
+      const label = pending ? '正在后台发现工具' : unknown && available === 0 ? '工具状态尚未确认'
+        : available === detailToolServers.length ? '已连接'
+        : available > 0 ? '部分服务可用' : '当前连接异常';
+      detailFailureState = pending ? 'unknown' : available > 0 ? 'healthy' : 'unavailable';
+      detailNeedsReconfigure = !pending && available === 0;
+      $('#detail-vendor').textContent = detailConnector.vendor ? `${detailConnector.vendor} · ${label}` : label;
+      $('#detail-try-btn').textContent = detailNeedsReconfigure ? '🔄 重新检查' : t('try');
+    }
+  }
 
   function scheduleStatusRefresh() {
     if (document.hidden) return;
+    statusRefreshPending = true;
+    if (statusRefreshRunning) return;
     clearTimeout(statusRefreshTimer);
-    statusRefreshTimer = setTimeout(() => {
-      if (view === 'market') loadMarket({ checkHealth: false, preserveScroll: true });
-      else loadInstalled();
+    statusRefreshTimer = setTimeout(async () => {
+      statusRefreshRunning = true;
+      statusRefreshPending = false;
+      try {
+        if (view === 'tools') await loadToolExplorer();
+        else if (view === 'market') await loadMarket({ checkHealth: false, preserveScroll: true });
+        else await loadInstalled();
+        await refreshOpenToolDetail();
+      } finally {
+        statusRefreshRunning = false;
+        if (statusRefreshPending) scheduleStatusRefresh();
+      }
     }, 150);
   }
 
@@ -1965,6 +2163,7 @@
     if (typeof EventSource !== 'function' || statusEventSource) return;
     const source = new EventSource('/mcp-connector/events');
     statusEventSource = source;
+    source.addEventListener('ready', scheduleStatusRefresh);
     source.addEventListener('status', (event) => {
       try {
         const payload = JSON.parse(event.data);
@@ -1989,8 +2188,11 @@
     statusEventSource = null;
   });
 
-  function refresh() { return view === 'market' ? loadMarket() : loadInstalled(); }
+  function refresh() { return view === 'tools' ? loadToolExplorer() : view === 'market' ? loadMarket() : loadInstalled(); }
   function syncTabs() {
+    searchInput.placeholder = view === 'tools' ? '搜索工具名称或描述…' : '搜索连接器…';
+    $('#refresh').textContent = view === 'tools' ? '刷新工具视图' : '刷新连接器目录';
+    $('#refresh').title = $('#refresh').textContent;
     document.querySelectorAll('#tabs button').forEach((button) => button.classList.toggle('active', button.dataset.view === view));
     syncMarketNav();
   }
@@ -2013,6 +2215,7 @@
     }
   });
   $('#refresh').addEventListener('click', async () => {
+    if (view === 'tools') { await loadToolExplorer(); return; }
     const r = await call('refreshCatalog', {});
     showToast(r.message, r.ok);
     if (r.ok) {
@@ -2026,12 +2229,16 @@
     const btn = e.target.closest('button[data-view]');
     if (!btn) return;
     view = btn.dataset.view;
+    explorerSequence++; explorerDetailSequence++;
     syncTabs();
     refresh();
   });
 
   searchInput.addEventListener('input', (e) => {
     searchQuery = e.target.value.trim();
+    explorerSequence++; explorerOffset = 0;
+    clearTimeout(searchTimer);
+    if (view === 'tools') { searchTimer = setTimeout(() => { if (view === 'tools') void loadToolExplorer(); }, 200); return; }
     expandedMarketSections.clear();
     refresh();
   });