dsh-mcp-connector 0.2.44 → 0.2.46

package/CHANGELOG.md

@@ -4,6 +4,37 @@
 
 ## [Unreleased]
 
+## [0.2.46] - 2026-09-13
+
+### Changed
+
+- 重写中英文 README 首屏，围绕接入 MCP Server、跨连接工具查找和连接排障统一产品表达，并用可核验的能力表替换竞品比较文案。
+- 扩充统一工具工作台用户指南，补齐来源定位、参数阅读、发现/缓存语义、连接检查与逐连接重新发现流程。
+- 同步 npm、GitHub About、README 与外部目录的双语描述，新增 npm 250 字符商店描述上限及用户结果关键词自动校验。
+
+### Verification
+
+- 248 项自动测试通过；4 张现有 storefront 截图通过完整性和无凭据检查；72 个发布文件通过白名单与敏感信息扫描。
+
+## [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
@@ -673,7 +704,11 @@
 - 外部 URL 与导入 Header 执行安全校验。
 - iframe 消息校验同源和消息来源。
 
-[Unreleased]: https://github.com/duhu2000/dsh-mcp-connector/compare/v0.2.42...HEAD
+[Unreleased]: https://github.com/duhu2000/dsh-mcp-connector/compare/v0.2.46...HEAD
+[0.2.46]: https://github.com/duhu2000/dsh-mcp-connector/compare/v0.2.45...v0.2.46
+[0.2.45]: https://github.com/duhu2000/dsh-mcp-connector/compare/v0.2.44...v0.2.45
+[0.2.44]: https://github.com/duhu2000/dsh-mcp-connector/compare/v0.2.43...v0.2.44
+[0.2.43]: https://github.com/duhu2000/dsh-mcp-connector/compare/v0.2.42...v0.2.43
 [0.2.42]: https://github.com/duhu2000/dsh-mcp-connector/compare/v0.2.41...v0.2.42
 [0.2.41]: https://github.com/duhu2000/dsh-mcp-connector/compare/v0.2.40...v0.2.41
 [0.2.40]: https://github.com/duhu2000/dsh-mcp-connector/compare/v0.2.39...v0.2.40

package/README.en.md

@@ -1,13 +1,21 @@
-# MCP Connector and MCP Server Marketplace for DeepSeek Harness
+# Connect, Find, and Troubleshoot MCP Servers in DeepSeek Harness
 
-> DeepSeek Harness MCP Connector and MCP Server marketplace with over one hundred MCP connectors, continuously updated; discover, authorize, and manage connections in one place with OAuth 2.0 PKCE, API keys, stdio/HTTP, mcpServers JSON import, and tool and prompt discovery; maintained by Qichacha/QCC
+> 100+ MCP connectors for DeepSeek Harness, one place to connect MCP servers, search tools across connections, and troubleshoot connections.
 
-Manage MCP connections from different providers in one place inside DeepSeek Harness Desktop/Web. Use OAuth 2.0 PKCE, API keys, stdio/HTTP, `mcpServers` JSON import, tool and prompt discovery, and an independently updated Registry of curated connectors.
+Connect MCP servers from a continuously updated catalog. Search tools across enabled connections in the current scope, inspect readable parameters, source metadata, and the last successful cache time, then check a connection or rediscover its tools when discovery fails. Supports OAuth 2.0 PKCE, API keys, Streamable HTTP/stdio, and `mcpServers` JSON import.
 
 > Here, “skill extension” means extending an agent through MCP tools and prompts; this package does not present itself as a standalone DSH Skill.
 
 [简体中文](README.md)
 
+### Tool discovery and troubleshooting
+
+Search cached tools across enabled connections visible to the current workspace in the Tools tab. Filter by connection, service and latest discovery status, then open parameter details for types, required fields and nested structures. Without a selected workspace, only global connections appear.
+
+Results identify their source and last successful cache time. A cached tool is not a guarantee that the service is currently callable. Expand connection diagnostics to check the connection or rediscover tools. Healthy discovery becomes due after five minutes; while the page remains connected, background scheduling checks due tasks. Failures back off, and authentication failures pause automatic retries.
+
+Tool browsing does not execute target tools. Parameter summaries may omit complex rules; the original-schema view contains the sanitized, size-limited cached schema, not an untouched server response. See the [Chinese tool-workspace guide](docs/USER-GUIDE.md#51-工具工作台统一查找工具).
+
 [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)
@@ -32,19 +40,18 @@ Fully restart DeepSeek Harness Desktop or `dsh web` after installation or upgrad
 
 If the plugin helps you connect an MCP server faster, consider [starring the repository](https://github.com/duhu2000/dsh-mcp-connector/stargazers), [submitting a connector](https://github.com/duhu2000/dsh-mcp-connector-registry/blob/main/docs/ONBOARDING.md), or [contributing a fix](CONTRIBUTING.md).
 
-## Why use MCP Connector
+## What MCP Connector provides
 
-| Capability | Basic MCP configuration panel | MCP Connector |
-|---|:---:|:---:|
-| Manual MCP server configuration | ✅ | ✅ |
-| Independently updated curated connector catalog | Usually not included | ✅ |
-| OAuth 2.0 PKCE and API keys | Partial | ✅ |
-| HTTP, stdio, and `mcpServers` JSON import | Partial | ✅ |
-| Tool and prompt discovery | Implementation-specific | ✅ |
-| Authorization recovery and connection lifecycle management | Usually not included | ✅ |
-| Connection health checks and Registry refresh | Usually not included | ✅ |
-| Explainable diagnostics and honest unknown state | Usually not included | ✅ |
-| Plugin version discovery and safe updates | Usually not included | ✅ |
+| Capability | What it gives you |
+|---|---|
+| Continuously updated catalog | Browse featured connectors and nine business categories; refresh after a Registry update to fetch new cards |
+| Multiple connection paths | Connect with OAuth 2.0 PKCE, API keys, Streamable HTTP/stdio, or `mcpServers` JSON |
+| Cross-connection tool search | Search the last-success cache of enabled connections in the current scope, then filter by connection, service, or state |
+| Readable parameters and sources | Inspect types, required fields, enums, nested summaries, sources, cache time, and a sanitized schema |
+| Connection troubleshooting | Use observed stages and stable error codes to check a connection or rediscover tools while retaining an available last-success cache |
+| Scope and governance | Manage project/global visibility plus Connection, Server, and Tool rules |
+| Safer lifecycle management | Keep credentials local, refresh grants, export redacted backups, restore snapshots, and preserve the previous connection on failure |
+| Plugin updates | Detect newer versions and, when the host exposes a compatible Update Provider, show progress, failures, and rollback results |
 
 ## Features
 
@@ -105,6 +112,7 @@ Run the same command again to upgrade. Fully quit and restart DeepSeek Harness D
 2. Choose a connector, confirm **Current project** or **All projects (global)**, and complete authorization or configuration.
 3. Open its details to inspect tools or send an example prompt to a new conversation draft.
 4. Use Installed or the conversation tools to enable, disable, inspect, or disconnect a connection.
+5. After connecting, open **Tools** to search by tool name or description and filter by connection or service. Provider authorization, fees, and actual execution remain under the provider and DSH Host.
 
 Connected tools are exposed to the model with the `mcp__<serverName>__*` prefix.
 
@@ -178,7 +186,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.44`](https://www.npmjs.com/package/dsh-mcp-connector), with [GitHub Release v0.2.44](https://github.com/duhu2000/dsh-mcp-connector/releases/tag/v0.2.44).
+The current public version is [`dsh-mcp-connector@0.2.46`](https://www.npmjs.com/package/dsh-mcp-connector), with [GitHub Release v0.2.46](https://github.com/duhu2000/dsh-mcp-connector/releases/tag/v0.2.46).
 
 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

@@ -1,13 +1,21 @@
-# MCP连接器：DeepSeek Harness MCP Server 连接与管理市场
+# MCP连接器：在 DeepSeek Harness 接入、查找和排障 MCP Server
 
-> DeepSeek Harness 的 MCP连接器与 MCP Server 市场，收录超百个 MCP连接器并持续更新；统一发现、授权和连接管理，支持 OAuth 2.0 PKCE、API Key、stdio/HTTP、mcpServers JSON 导入，以及工具与 Prompt 发现；由企查查/QCC 团队维护
+> DeepSeek Harness 的超百个 MCP连接器，一个入口完成 MCP Server 接入、跨连接工具查找与连接排障。
 
-在 DeepSeek Harness Desktop/Web 中一站式管理不同厂商的 MCP 连接：支持 OAuth 2.0 PKCE、API Key、stdio/HTTP、`mcpServers` JSON 导入、工具与 Prompt 发现，并通过独立 Registry 持续更新精选连接器目录。
+从持续更新的连接器目录接入 MCP Server；跨当前范围内已启用连接查找工具，查看易读参数、来源和最后成功缓存时间，并在发现异常时检查连接或重新发现工具。支持 OAuth 2.0 PKCE、API Key、Streamable HTTP/stdio 与 `mcpServers` JSON 导入。
 
 > 注：“技能扩展”指通过 MCP 工具和 Prompt 扩展智能体能力，本包不会伪装成独立 DSH Skill。
 
 [English](README.en.md)
 
+### 工具查找与故障处理
+
+在“工具”页统一查找当前工作区可见、已启用连接的工具。输入工具名或描述，再按连接、服务和最近发现状态筛选；点击“参数详情”查看类型、必填项与嵌套结构。未选择工作区时，仅展示全局连接。
+
+结果标注来源和最后成功缓存时间。发现失败时仍可查看已有缓存，但不代表服务当前可调用。展开“连接状态与故障处理”，按建议使用“检查连接”或“重新发现工具”。健康连接五分钟后到期，页面保持连接时后台检查到期任务；失败时退避，鉴权失败暂停自动重试。
+
+详见[工具工作台教程](docs/USER-GUIDE.md#51-工具工作台统一查找工具)。工具页用于发现与诊断，不执行目标工具；参数摘要与原始安全缓存均有裁剪边界。
+
 [用户手册](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)
@@ -32,19 +40,18 @@ dsh plugin --profile web add dsh-mcp-connector
 
 如果它帮你更快地接入 MCP Server，欢迎 [GitHub 点个 Star](https://github.com/duhu2000/dsh-mcp-connector/stargazers)、[提交新的连接器](https://github.com/duhu2000/dsh-mcp-connector-registry/blob/main/docs/ONBOARDING.md)或[参与贡献](CONTRIBUTING.md)。
 
-## 为什么使用 MCP连接器
+## MCP连接器能做什么
 
-| 能力 | 普通 MCP 配置面板 | MCP连接器 |
-|---|:---:|:---:|
-| 手工配置 MCP Server | ✅ | ✅ |
-| 持续更新的精选连接器目录 | 通常无 | ✅ |
-| OAuth 2.0 PKCE 与 API Key | 部分 | ✅ |
-| HTTP、stdio 与 `mcpServers` JSON 导入 | 部分 | ✅ |
-| 工具与 Prompt 发现 | 视实现而定 | ✅ |
-| 授权恢复与连接生命周期管理 | 通常无 | ✅ |
-| 连接健康检查与 Registry 刷新 | 通常无 | ✅ |
-| 可解释诊断与诚实的未知状态 | 通常无 | ✅ |
-| 插件版本检测与安全更新 | 通常无 | ✅ |
+| 能力 | 用户得到什么 |
+|---|---|
+| 持续更新的连接器目录 | 浏览精选与 9 类业务连接器；Registry 更新后刷新即可获取新卡片 |
+| 多种接入方式 | 使用 OAuth 2.0 PKCE、API Key、Streamable HTTP/stdio 或 `mcpServers` JSON 接入 |
+| 跨连接工具查找 | 在当前范围内已启用连接的最后成功缓存中按名称或描述搜索，并按连接、服务和状态筛选 |
+| 易读参数与来源 | 查看类型、必填、枚举、嵌套摘要、来源、缓存时间及安全裁剪后的 Schema |
+| 连接排障 | 根据明确的阶段和错误码检查连接或重新发现工具，同时保留可用的最后成功缓存 |
+| 作用域与治理 | 管理 project/global 可见范围以及 Connection、Server、Tool 三层规则 |
+| 安全生命周期 | 支持凭据本机存储、授权刷新、脱敏备份、快照回滚及失败时保留原连接 |
+| 插件更新 | 检测新版本，并在宿主提供兼容 Update Provider 时显示进度、失败原因和回滚结果 |
 
 ## 功能
 
@@ -106,6 +113,7 @@ bash <(curl -fsSL https://raw.githubusercontent.com/duhu2000/dsh-mcp-connector/m
 2. 在市场中选择连接器，确认“当前项目”或“所有项目（全局）”，再完成授权或配置。
 3. 打开卡片详情，可点击示例 Prompt 的发送按钮，在当前工作区创建/复用空白会话并写入草稿。
 4. 在“已安装”或对话工具中查看、停用、恢复或断开连接。
+5. 连接后打开“工具”页，按工具名或描述查找能力，使用连接/服务筛选定位来源；授权、费用及正式调用仍由相应服务与 DSH Host 管理。
 
 连接成功后，工具按 `mcp__<serverName>__*` 前缀提供给模型。
 
@@ -173,7 +181,7 @@ npm run dev:ui
 
 公共 Registry 每次合并后会生成 `catalog-stats.json`；本仓库的定时工作流每小时同步中英文介绍和统计快照。npm 页面中的静态正文随版本发布更新，上方动态统计徽标则直接读取 Registry，可在不发布新 npm 版本时保持实时数量一致。
 
-当前公开版本为 [`dsh-mcp-connector@0.2.44`](https://www.npmjs.com/package/dsh-mcp-connector)，对应 [GitHub Release v0.2.44](https://github.com/duhu2000/dsh-mcp-connector/releases/tag/v0.2.44)。
+当前公开版本为 [`dsh-mcp-connector@0.2.46`](https://www.npmjs.com/package/dsh-mcp-connector)，对应 [GitHub Release v0.2.46](https://github.com/duhu2000/dsh-mcp-connector/releases/tag/v0.2.46)。
 
 版本能力与变更记录见 [CHANGELOG.md](CHANGELOG.md)。
 Desktop 发版回归见 [docs/DESKTOP-E2E.md](docs/DESKTOP-E2E.md)。

package/docs/USER-GUIDE.md

@@ -106,6 +106,34 @@ OAuth 一键连接要求服务商支持标准 OAuth 2.1/PKCE 和公开元数据
 
 对话中可用 `mcp_connector_tool_search` 按名称、标题或描述搜索缓存，再用 `mcp_connector_tool_detail` 精确读取某个工具的参数 schema。两者只用于发现，不代理或执行 MCP 调用。
 
+### 5.1 工具工作台：统一查找工具
+
+1. 先连接所需 MCP 服务，打开顶部“工具”页；工具发现会在后台进行，无需先打开每个连接的详情。
+2. 输入工具名或描述中的关键词。精确工具名优先；同名工具仍可能来自不同连接，请核对来源。
+3. 使用“连接”“服务”“发现状态”筛选缩小范围，点击“清除筛选”恢复。结果按页展示。
+4. 工具页搜索的是已启用且当前范围可见连接的成功缓存，不是市场中所有未安装连接器的工具。未选择 Workspace 时仅显示全局连接。
+5. 没有结果时先清除筛选，并确认连接已启用、范围正确且至少成功发现过一次；首次发现可能仍在等待。
+
+### 5.2 查看参数与来源
+
+每条结果展示连接器、连接、服务、最近发现状态和最后成功缓存时间。点击“参数详情”查看类型、必填、说明、枚举和嵌套结构。
+
+复杂引用、组合规则或过大结构会提示摘要限制；可展开“原始 Schema（安全缓存）”继续查看。这里的原始 Schema 仍是安全裁剪后的缓存，不含被移除的默认值或示例，也不保证保留超限字段。此页不执行工具。
+
+### 5.3 发现状态和最后成功缓存
+
+“尚未发现”表示还没有当前发现状态；“Host 状态未知”表示宿主状态无法确认；“最近发现成功/失败”仅代表最近一次发现，不保证随后调用的结果。
+
+失败时已有的最后成功工具缓存仍可查看；超过 24 小时会提示陈旧。没有成功记录则无法提供缓存，成功空列表也不代表故障。连接改配、停用或断开可能使原结果不再可见。
+
+### 5.4 检查连接与重新发现
+
+展开“连接状态与故障处理”，先阅读阶段与建议。“检查连接”执行该连接的健康检查；“重新发现工具”重新获取该连接的工具元数据。两者不是目标工具试运行，也不保证自动修复。
+
+同连接进行中的操作会合并，频繁操作有冷却；工具页操作不能绕过有效限流等待。鉴权失败请到“已安装”页更新凭据或重新授权。
+
+健康后台发现五分钟后到期；页面保持 SSE 连接时按调度检查到期项，普通故障指数退避，限流结合 `Retry-After` 等待，鉴权失败暂停自动重试。不要把“刷新工具视图”误认为强制访问所有服务，它只刷新缓存视图。
+
 ## 6. 添加自定义连接
 
 点击“＋ 添加连接”后有三种方式。

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,
@@ -170,6 +172,10 @@ export async function apply(ctx, config) {
   };
   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,
@@ -1008,6 +1014,8 @@ 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) {
@@ -1038,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];
@@ -2311,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());
@@ -2369,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;
@@ -2654,6 +2710,48 @@ 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;
@@ -2678,7 +2776,6 @@ export async function apply(ctx, config) {
           const view = state.toolViews.get(record.key);
           return view?.record === record && !view.server.ok;
         }).length;
-        if (pendingServers > 0) scheduleDiscovery();
         return {
           ok: true,
           message: `最后成功工具缓存中找到 ${items.length} 个匹配项${staleCount ? `，其中 ${staleCount} 个已超过 24 小时` : ''}${pendingServers ? `；${pendingServers} 个服务正在后台发现` : ''}${failedServers ? `；${failedServers} 个服务最近读取失败` : ''}`,
@@ -2894,6 +2991,7 @@ export async function apply(ctx, config) {
               ok: false,
               error: error.message,
               errorKind: error.kind,
+              retryAfterMs: error.retryAfterMs,
               policy: serverPolicy(record),
               ...cachedFields,
             });
@@ -2909,7 +3007,10 @@ export async function apply(ctx, config) {
       }
       records.forEach((record, index) => {
         if (state.connections.get(record.key) === record && record.enabled !== false) {
-          state.toolViews.set(record.key, { record, server: servers[index] });
+          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);
@@ -3057,15 +3158,19 @@ export async function apply(ctx, config) {
     discoveryRunning = true;
     discoveryPending = false;
     try {
-      const ids = [...new Set([...state.connections.values()].filter((record) => record.enabled !== false).map((record) => record.connectorId))];
+      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, ids.length) }, async () => {
-        while (cursor < ids.length && !discoveryDisposed) {
-          const id = ids[cursor++];
-          await api.toolsList(id).catch(() => {});
+      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');
         }
       }));
-      if (!discoveryDisposed) statusEvents.publish('tools');
     } finally {
       discoveryRunning = false;
       if (discoveryPending) scheduleDiscovery();

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/tool-catalog-cache.js

@@ -167,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,
@@ -191,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/web.js

@@ -50,6 +50,9 @@ const API_WHITELIST = new Map([
   ['refreshCatalog', (api) => api.refreshCatalog()],
   ['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,7 +1,7 @@
 {
   "name": "dsh-mcp-connector",
-  "version": "0.2.44",
-  "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.",
+  "version": "0.2.46",
+  "description": "DeepSeek Harness MCP Connector: connect servers, search tools across active connections, and troubleshoot discovery. Includes a continuously updated catalog; supports OAuth 2.0 PKCE, API keys, Streamable HTTP/stdio, and mcpServers JSON import.",
   "type": "module",
   "main": "lib/index.js",
   "exports": {
@@ -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) {
@@ -965,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;
@@ -1153,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>';
@@ -2034,7 +2148,8 @@
       statusRefreshRunning = true;
       statusRefreshPending = false;
       try {
-        if (view === 'market') await loadMarket({ checkHealth: false, preserveScroll: true });
+        if (view === 'tools') await loadToolExplorer();
+        else if (view === 'market') await loadMarket({ checkHealth: false, preserveScroll: true });
         else await loadInstalled();
         await refreshOpenToolDetail();
       } finally {
@@ -2073,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();
   }
@@ -2097,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) {
@@ -2110,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();
   });