@konbakuyomu/smart-search-darwin-arm64 0.1.32 → 0.1.34

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@konbakuyomu/smart-search-darwin-arm64",
-  "version": "0.1.32",
+  "version": "0.1.34",
   "description": "Self-contained Smart Search CLI for darwin/arm64",
   "license": "MIT",
   "repository": {

package/runtime/smart-search/_internal/smart_search/assets/i18n/messages.json

@@ -1447,6 +1447,54 @@
     "TinyFish 搜索与抓取 API 均可用",
     "Both TinyFish search and fetch APIs are available"
   ],
+  "Invalid OPENAI_COMPATIBLE_TOOLS: {0}. Supported values: {1}": [
+    "无效的 OPENAI_COMPATIBLE_TOOLS：{0}。支持：{1}",
+    "Invalid OPENAI_COMPATIBLE_TOOLS: {0}. Supported values: {1}"
+  ],
+  "OPENAI_COMPATIBLE_TOOLS only works with OPENAI_COMPATIBLE_API_MODE=responses. Set the API mode to responses, or clear OPENAI_COMPATIBLE_TOOLS.": [
+    "OPENAI_COMPATIBLE_TOOLS 只在 OPENAI_COMPATIBLE_API_MODE=responses 时生效。请把接口模式改成 responses，或清空 OPENAI_COMPATIBLE_TOOLS。",
+    "OPENAI_COMPATIBLE_TOOLS only works with OPENAI_COMPATIBLE_API_MODE=responses. Set the API mode to responses, or clear OPENAI_COMPATIBLE_TOOLS."
+  ],
+  "OPENAI_COMPATIBLE_TOOLS 只在 OPENAI_COMPATIBLE_API_MODE=responses 时生效。请把接口模式改成 responses，或清空 OPENAI_COMPATIBLE_TOOLS。": [
+    "OPENAI_COMPATIBLE_TOOLS 只在 OPENAI_COMPATIBLE_API_MODE=responses 时生效。请把接口模式改成 responses，或清空 OPENAI_COMPATIBLE_TOOLS。",
+    "OPENAI_COMPATIBLE_TOOLS only works with OPENAI_COMPATIBLE_API_MODE=responses. Set the API mode to responses, or clear OPENAI_COMPATIBLE_TOOLS."
+  ],
+  "OpenAI 兼容联网工具": [
+    "OpenAI 兼容联网工具",
+    "openai-compatible tools"
+  ],
+  "OpenAI-compatible tools are invalid.": [
+    "OpenAI-compatible 联网工具配置无效。",
+    "OpenAI-compatible tools are invalid."
+  ],
+  "OpenAI-compatible was rate limited upstream (HTTP 429), so this diagnosis cannot tell whether the route works.": [
+    "OpenAI-compatible 被上游限流（HTTP 429），这次诊断判断不了链路是否正常。",
+    "OpenAI-compatible was rate limited upstream (HTTP 429), so this diagnosis cannot tell whether the route works."
+  ],
+  "OpenAI-compatible 联网工具配置无效。": [
+    "OpenAI-compatible 联网工具配置无效。",
+    "OpenAI-compatible tools are invalid."
+  ],
+  "OpenAI-compatible 被上游限流（HTTP 429），这次诊断判断不了链路是否正常。": [
+    "OpenAI-compatible 被上游限流（HTTP 429），这次诊断判断不了链路是否正常。",
+    "OpenAI-compatible was rate limited upstream (HTTP 429), so this diagnosis cannot tell whether the route works."
+  ],
+  "Run this diagnosis again in a minute; if it keeps happening, lower concurrency, switch models, or raise the account's rate limit. The URL, key and model name are not necessarily wrong.": [
+    "等一分钟再运行本诊断；经常出现就降低并发、换模型，或提高账户的速率额度。地址、key 和模型名不一定有问题。",
+    "Run this diagnosis again in a minute; if it keeps happening, lower concurrency, switch models, or raise the account's rate limit. The URL, key and model name are not necessarily wrong."
+  ],
+  "Save OPENAI_COMPATIBLE_TOOLS (web_search or web_search_preview; needs --openai-compatible-api-mode responses).": [
+    "保存 OPENAI_COMPATIBLE_TOOLS（web_search 或 web_search_preview；需要 --openai-compatible-api-mode responses）。",
+    "Save OPENAI_COMPATIBLE_TOOLS (web_search or web_search_preview; needs --openai-compatible-api-mode responses)."
+  ],
+  "Strict validation needs sources that a search service retrieved on its own; this run only has the search model's own citations, which are not independent evidence. Configure a web_search provider (for example Tavily, Zhipu or Yuanbao Search) before using strict, or switch to balanced.": [
+    "strict 校验需要搜索服务独立检索到的来源；这次只有搜索模型自带的引用，不算独立证据。配置一个 web_search 提供方（例如 Tavily、智谱、元宝搜索）后再用 strict，或改用 balanced。",
+    "Strict validation needs sources that a search service retrieved on its own; this run only has the search model's own citations, which are not independent evidence. Configure a web_search provider (for example Tavily, Zhipu or Yuanbao Search) before using strict, or switch to balanced."
+  ],
+  "Use OPENAI_COMPATIBLE_TOOLS=web_search (or web_search_preview) only with OPENAI_COMPATIBLE_API_MODE=responses; otherwise leave it empty.": [
+    "只在 OPENAI_COMPATIBLE_API_MODE=responses 时把 OPENAI_COMPATIBLE_TOOLS 设为 web_search（或 web_search_preview）；其他情况留空。",
+    "Use OPENAI_COMPATIBLE_TOOLS=web_search (or web_search_preview) only with OPENAI_COMPATIBLE_API_MODE=responses; otherwise leave it empty."
+  ],
   "Yuanbao Search API is available": [
     "元宝搜索 API 可用",
     "Yuanbao Search API is available"
@@ -4663,6 +4711,14 @@
     "OpenAI 兼容 API 模式",
     "openai-compatible API mode"
   ],
+  "openai-compatible tools": [
+    "OpenAI 兼容联网工具",
+    "openai-compatible tools"
+  ],
+  "strict 校验需要搜索服务独立检索到的来源；这次只有搜索模型自带的引用，不算独立证据。配置一个 web_search 提供方（例如 Tavily、智谱、元宝搜索）后再用 strict，或改用 balanced。": [
+    "strict 校验需要搜索服务独立检索到的来源；这次只有搜索模型自带的引用，不算独立证据。配置一个 web_search 提供方（例如 Tavily、智谱、元宝搜索）后再用 strict，或改用 balanced。",
+    "Strict validation needs sources that a search service retrieved on its own; this run only has the search model's own citations, which are not independent evidence. Configure a web_search provider (for example Tavily, Zhipu or Yuanbao Search) before using strict, or switch to balanced."
+  ],
   "xai-responses 流式": [
     "xai-responses 流式",
     "xai-responses stream"
@@ -7423,6 +7479,34 @@
     "TinyFish 搜索与抓取 API 均可用",
     "Both TinyFish search and fetch APIs are available"
   ],
+  "{0} Also, the web search capability check did not pass: {1}. If this model can only search through the Responses web_search tool (for example OpenAI's gpt-6.1-sol), set OPENAI_COMPATIBLE_API_MODE=responses and OPENAI_COMPATIBLE_TOOLS=web_search; use web_search_preview for relays that only know the older name.": [
+    "{0} 另外，联网搜索能力检查未通过：{1}。如果这个模型只能通过 Responses 的 web_search 工具联网（例如 OpenAI 官方的 gpt-6.1-sol），请设置 OPENAI_COMPATIBLE_API_MODE=responses 和 OPENAI_COMPATIBLE_TOOLS=web_search；中转站只认旧名时改用 web_search_preview。",
+    "{0} Also, the web search capability check did not pass: {1}. If this model can only search through the Responses web_search tool (for example OpenAI's gpt-6.1-sol), set OPENAI_COMPATIBLE_API_MODE=responses and OPENAI_COMPATIBLE_TOOLS=web_search; use web_search_preview for relays that only know the older name."
+  ],
+  "{0} Also, the web search capability check did not pass: {1}. The request already carried the {2} tool, so this model or relay may not support Responses web search tools; switch to a model that does, or clear OPENAI_COMPATIBLE_TOOLS and use a model that searches on its own.": [
+    "{0} 另外，联网搜索能力检查未通过：{1}。请求里已经带了 {2} 工具，可能是这个模型或中转站不支持 Responses 的联网工具；换一个支持的模型，或清空 OPENAI_COMPATIBLE_TOOLS 改用自带搜索的模型。",
+    "{0} Also, the web search capability check did not pass: {1}. The request already carried the {2} tool, so this model or relay may not support Responses web search tools; switch to a model that does, or clear OPENAI_COMPATIBLE_TOOLS and use a model that searches on its own."
+  ],
+  "{0} does not support x_search in XAI_TOOLS (HTTP 400). Only the official xAI API serves x_search; set XAI_TOOLS to web_search and try again.": [
+    "{0} 不支持 XAI_TOOLS 里的 x_search（HTTP 400）。x_search 只有 xAI 官方接口能用；把 XAI_TOOLS 改成 web_search 再试。",
+    "{0} does not support x_search in XAI_TOOLS (HTTP 400). Only the official xAI API serves x_search; set XAI_TOOLS to web_search and try again."
+  ],
+  "{0} 不支持 XAI_TOOLS 里的 x_search（HTTP 400）。x_search 只有 xAI 官方接口能用；把 XAI_TOOLS 改成 web_search 再试。": [
+    "{0} 不支持 XAI_TOOLS 里的 x_search（HTTP 400）。x_search 只有 xAI 官方接口能用；把 XAI_TOOLS 改成 web_search 再试。",
+    "{0} does not support x_search in XAI_TOOLS (HTTP 400). Only the official xAI API serves x_search; set XAI_TOOLS to web_search and try again."
+  ],
+  "{0} 另外，联网搜索能力检查未通过：{1}。如果这个模型只能通过 Responses 的 web_search 工具联网（例如 OpenAI 官方的 gpt-6.1-sol），请设置 OPENAI_COMPATIBLE_API_MODE=responses 和 OPENAI_COMPATIBLE_TOOLS=web_search；中转站只认旧名时改用 web_search_preview。": [
+    "{0} 另外，联网搜索能力检查未通过：{1}。如果这个模型只能通过 Responses 的 web_search 工具联网（例如 OpenAI 官方的 gpt-6.1-sol），请设置 OPENAI_COMPATIBLE_API_MODE=responses 和 OPENAI_COMPATIBLE_TOOLS=web_search；中转站只认旧名时改用 web_search_preview。",
+    "{0} Also, the web search capability check did not pass: {1}. If this model can only search through the Responses web_search tool (for example OpenAI's gpt-6.1-sol), set OPENAI_COMPATIBLE_API_MODE=responses and OPENAI_COMPATIBLE_TOOLS=web_search; use web_search_preview for relays that only know the older name."
+  ],
+  "{0} 另外，联网搜索能力检查未通过：{1}。请求里已经带了 {2} 工具，可能是这个模型或中转站不支持 Responses 的联网工具；换一个支持的模型，或清空 OPENAI_COMPATIBLE_TOOLS 改用自带搜索的模型。": [
+    "{0} 另外，联网搜索能力检查未通过：{1}。请求里已经带了 {2} 工具，可能是这个模型或中转站不支持 Responses 的联网工具；换一个支持的模型，或清空 OPENAI_COMPATIBLE_TOOLS 改用自带搜索的模型。",
+    "{0} Also, the web search capability check did not pass: {1}. The request already carried the {2} tool, so this model or relay may not support Responses web search tools; switch to a model that does, or clear OPENAI_COMPATIBLE_TOOLS and use a model that searches on its own."
+  ],
+  "保存 OPENAI_COMPATIBLE_TOOLS（web_search 或 web_search_preview；需要 --openai-compatible-api-mode responses）。": [
+    "保存 OPENAI_COMPATIBLE_TOOLS（web_search 或 web_search_preview；需要 --openai-compatible-api-mode responses）。",
+    "Save OPENAI_COMPATIBLE_TOOLS (web_search or web_search_preview; needs --openai-compatible-api-mode responses)."
+  ],
   "元宝搜索 API 可用": [
     "元宝搜索 API 可用",
     "Yuanbao Search API is available"
@@ -8783,6 +8867,10 @@
     "可选；设置后在 xAI Responses 请求中发送 reasoning.effort，默认不发送。",
     "Optional; when set, sends reasoning.effort in xAI Responses requests; omitted by default."
   ],
+  "只在 OPENAI_COMPATIBLE_API_MODE=responses 时把 OPENAI_COMPATIBLE_TOOLS 设为 web_search（或 web_search_preview）；其他情况留空。": [
+    "只在 OPENAI_COMPATIBLE_API_MODE=responses 时把 OPENAI_COMPATIBLE_TOOLS 设为 web_search（或 web_search_preview）；其他情况留空。",
+    "Use OPENAI_COMPATIBLE_TOOLS=web_search (or web_search_preview) only with OPENAI_COMPATIBLE_API_MODE=responses; otherwise leave it empty."
+  ],
   "可选；设置后在 xAI Responses 请求中发送 reasoning.effort，默认不发送。": [
     "可选；设置后在 xAI Responses 请求中发送 reasoning.effort，默认不发送。",
     "Optional; when set, sends reasoning.effort in xAI Responses requests; omitted by default."
@@ -11703,6 +11791,10 @@
     "无效的 --timeout：{0}。需要有限的正数。",
     "Invalid --timeout: {0}. Expected a positive finite number."
   ],
+  "无效的 OPENAI_COMPATIBLE_TOOLS：{0}。支持：{1}": [
+    "无效的 OPENAI_COMPATIBLE_TOOLS：{0}。支持：{1}",
+    "Invalid OPENAI_COMPATIBLE_TOOLS: {0}. Supported values: {1}"
+  ],
   "无效的 OpenAI 兼容 API 模式：{0}。支持：{1}": [
     "无效的 OpenAI 兼容 API 模式：{0}。支持：{1}",
     "Invalid OpenAI-compatible API mode: {0}. Supported values: {1}"
@@ -13655,6 +13747,10 @@
     "站点地图",
     "Site map"
   ],
+  "等一分钟再运行本诊断；经常出现就降低并发、换模型，或提高账户的速率额度。地址、key 和模型名不一定有问题。": [
+    "等一分钟再运行本诊断；经常出现就降低并发、换模型，或提高账户的速率额度。地址、key 和模型名不一定有问题。",
+    "Run this diagnosis again in a minute; if it keeps happening, lower concurrency, switch models, or raise the account's rate limit. The URL, key and model name are not necessarily wrong."
+  ],
   "等多久、失败之后怎么办、冷却多长时间。默认值适合大多数人。": [
     "等多久、失败之后怎么办、冷却多长时间。默认值适合大多数人。",
     "How long to wait, what happens after a failure, how long a dead provider stays out. The defaults suit most people."
@@ -17943,10 +18039,6 @@
     "尚未配置 Jev 独立汇总模型",
     "Jev synthesis model is not configured"
   ],
-  "{0} 另外，联网搜索能力检查未通过：{1}。OpenAI-compatible 不会发送搜索工具；如果该模型只能通过 Responses 的 web_search 工具联网，请把 XAI_API_URL、XAI_API_KEY、XAI_MODEL 指向支持 /v1/responses 的中转站。": [
-    "{0} 另外，联网搜索能力检查未通过：{1}。OpenAI-compatible 不会发送搜索工具；如果该模型只能通过 Responses 的 web_search 工具联网，请把 XAI_API_URL、XAI_API_KEY、XAI_MODEL 指向支持 /v1/responses 的中转站。",
-    "{0} Also, the web search capability check did not pass: {1}. OpenAI-compatible sends no search tool; if this model can only search through the Responses web_search tool, point XAI_API_URL, XAI_API_KEY and XAI_MODEL at a relay that supports /v1/responses."
-  ],
   "DeepSeek search response is not a JSON object": [
     "DeepSeek 搜索响应不是 JSON 对象",
     "DeepSeek search response is not a JSON object"

package/runtime/smart-search/_internal/smart_search/assets/skills/smart-search-cli/SKILL.md

@@ -23,7 +23,7 @@ Use the local `smart-search` command as the default execution layer for web rese
 1. Run `smart-search doctor --format json` when configuration or availability is uncertain.
 2. If `doctor` reports missing configuration, use `smart-search setup` or `smart-search config set KEY VALUE` when the user provides keys. Do not ask users to edit global environment variables by default.
 3. If OpenAI-compatible `search` hangs or times out after `doctor` succeeds, run `smart-search diagnose openai-compatible --format markdown` and use its summary.
-4. Keep `OPENAI_COMPATIBLE_API_MODE=chat-completions` unless a named relay has passed the official Responses subset probes; set `responses` only for that relay and keep the diagnostic evidence.
+4. Keep `OPENAI_COMPATIBLE_API_MODE=chat-completions` unless a named relay has passed the official Responses subset probes; set `responses` only for that relay and keep the diagnostic evidence. For a model that searches only through the Responses `web_search` tool (for example `gpt-6.1-sol` with an official OpenAI key), also set `OPENAI_COMPATIBLE_TOOLS=web_search`.
 5. If `doctor` returns `ok: true`, use only `smart-search` CLI subcommands for web research. Do not call Codex native web search in the same task.
 6. Use `smart-search skills status --targets codex --format json` when the installed global skill may be stale; use `smart-search skills update --targets codex --format json` to refresh it without rerunning setup.
 7. Use `smart-search smoke --mock --format json` after CLI/provider architecture changes. Use `--live` only when real keys are available and the user expects live checks.

package/runtime/smart-search/_internal/smart_search/assets/skills/smart-search-cli/references/cli-core.md

@@ -48,7 +48,7 @@
 - `smart-search map URL [--instructions TEXT] [--max-depth N] [--max-breadth N] [--limit N] [--timeout SECONDS] [--format json|markdown|content] [--output PATH]`
 - `smart-search doctor [--format json|markdown|content] [--output PATH]`
 - `smart-search diagnose openai-compatible [--timeout SECONDS] [--format json|markdown] [--output PATH]`
-- `smart-search setup [--lang zh|en] [--advanced] [--non-interactive] [--skip-skills] [--install-skills CSV] [--skills-root PATH] [--xai-api-url URL] [--xai-api-key KEY] [--xai-model ID] [--xai-tools-explicit CSV] [--xai-stream true|false] [--openai-compatible-api-url URL] [--openai-compatible-api-key KEY] [--openai-compatible-model ID] [--openai-compatible-fallback-models CSV] [--openai-compatible-api-mode chat-completions|responses] [--openai-compatible-stream true|false] [--validation-level fast|balanced|strict] [--fallback-mode auto|off] [--minimum-profile standard|off] [--intent-router jev|local] [--search-timeout SECONDS] [--provider-cooldown SECONDS] [--provider-failure-threshold N] [--exa-key KEY] [--context7-key KEY] [--zhipu-key KEY] [--zhipu-api-url URL] [--zhipu-search-engine ENGINE] [--zhipu-mcp-key KEY] [--zhipu-mcp-search-api-url URL] [--zhipu-mcp-reader-api-url URL] [--zhipu-mcp-zread-api-url URL] [--zhipu-mcp-timeout SECONDS] [--jina-key KEY] [--jina-reader-api-url URL] [--jina-respond-with MODE] [--jina-timeout SECONDS] [--tavily-api-url URL] [--tavily-key KEY] [--firecrawl-api-url URL] [--firecrawl-key KEY] [--tinyfish-key KEY] [--tinyfish-search-api-url URL] [--tinyfish-fetch-api-url URL] [--tinyfish-timeout SECONDS] [--yuanbao-secret-id ID] [--yuanbao-secret-key KEY] [--yuanbao-api-url URL] [--yuanbao-timeout SECONDS] [--deepseek-key KEY] [--deepseek-api-url URL] [--deepseek-timeout SECONDS] [--anysearch-api-url URL] [--anysearch-key KEY] [--anysearch-timeout SECONDS] [--sciverse-api-url URL] [--sciverse-token TOKEN] [--sciverse-timeout SECONDS] [--format json|markdown|content] [--output PATH]`
+- `smart-search setup [--lang zh|en] [--advanced] [--non-interactive] [--skip-skills] [--install-skills CSV] [--skills-root PATH] [--xai-api-url URL] [--xai-api-key KEY] [--xai-model ID] [--xai-tools-explicit CSV] [--xai-stream true|false] [--openai-compatible-api-url URL] [--openai-compatible-api-key KEY] [--openai-compatible-model ID] [--openai-compatible-fallback-models CSV] [--openai-compatible-api-mode chat-completions|responses] [--openai-compatible-tools web_search|web_search_preview] [--openai-compatible-stream true|false] [--validation-level fast|balanced|strict] [--fallback-mode auto|off] [--minimum-profile standard|off] [--intent-router jev|local] [--search-timeout SECONDS] [--provider-cooldown SECONDS] [--provider-failure-threshold N] [--exa-key KEY] [--context7-key KEY] [--zhipu-key KEY] [--zhipu-api-url URL] [--zhipu-search-engine ENGINE] [--zhipu-mcp-key KEY] [--zhipu-mcp-search-api-url URL] [--zhipu-mcp-reader-api-url URL] [--zhipu-mcp-zread-api-url URL] [--zhipu-mcp-timeout SECONDS] [--jina-key KEY] [--jina-reader-api-url URL] [--jina-respond-with MODE] [--jina-timeout SECONDS] [--tavily-api-url URL] [--tavily-key KEY] [--firecrawl-api-url URL] [--firecrawl-key KEY] [--tinyfish-key KEY] [--tinyfish-search-api-url URL] [--tinyfish-fetch-api-url URL] [--tinyfish-timeout SECONDS] [--yuanbao-secret-id ID] [--yuanbao-secret-key KEY] [--yuanbao-api-url URL] [--yuanbao-timeout SECONDS] [--deepseek-key KEY] [--deepseek-api-url URL] [--deepseek-timeout SECONDS] [--anysearch-api-url URL] [--anysearch-key KEY] [--anysearch-timeout SECONDS] [--sciverse-api-url URL] [--sciverse-token TOKEN] [--sciverse-timeout SECONDS] [--format json|markdown|content] [--output PATH]`
 - `smart-search config path|list|set|unset ... [--format json|markdown|content] [--output PATH]`
 - `smart-search model set MODEL [--format json|markdown|content] [--output PATH]`
 - `smart-search model current [--format json|markdown|content] [--output PATH]`

package/runtime/smart-search/_internal/smart_search/assets/skills/smart-search-cli/references/command-patterns.md

@@ -58,6 +58,7 @@ smart-search skills update --all --format json
 smart-search route "React useEffect API docs" --format markdown
 smart-search setup --non-interactive --zhipu-api-url "https://open.bigmodel.cn/api" --zhipu-search-engine "search_std"
 smart-search setup --non-interactive --openai-compatible-api-mode responses
+smart-search setup --non-interactive --openai-compatible-api-mode responses --openai-compatible-tools web_search
 smart-search setup --non-interactive --openai-compatible-stream true
 smart-search setup --non-interactive --openai-compatible-fallback-models "model-a,model-b"
 smart-search setup --non-interactive --anysearch-api-url "https://api.anysearch.com/mcp" --anysearch-key "key"
@@ -77,6 +78,7 @@ smart-search config set OPENAI_COMPATIBLE_API_URL "https://api.openai.com/v1" --
 smart-search config set OPENAI_COMPATIBLE_API_KEY "key" --format json
 smart-search config set OPENAI_COMPATIBLE_MODEL "model-id" --format json
 smart-search config set OPENAI_COMPATIBLE_API_MODE "responses" --format json
+smart-search config set OPENAI_COMPATIBLE_TOOLS "web_search" --format json
 smart-search config set OPENAI_COMPATIBLE_FALLBACK_MODELS "model-a,model-b" --format json
 smart-search config set OPENAI_COMPATIBLE_STREAM "true" --format json
 smart-search config set SMART_SEARCH_TIMEOUT_SECONDS "180" --format json

package/runtime/smart-search/_internal/smart_search/assets/skills/smart-search-cli/references/provider-routing.md

@@ -27,7 +27,7 @@ For research, `SMART_SEARCH_JEV_SYNTHESIZE` accepts `true`, `false`, and `auto`.
 - Legacy `SMART_SEARCH_API_URL`, `SMART_SEARCH_API_KEY`, `SMART_SEARCH_API_MODE`, `SMART_SEARCH_MODEL`, and `SMART_SEARCH_XAI_TOOLS` are unsupported config keys.
 - xAI Responses mode may use only `XAI_TOOLS=web_search,x_search` and a subset of those tools.
 - `XAI_REASONING_EFFORT` accepts `low`, `medium`, or `high` (case-insensitive, stored lowercase). Optional; when set, sends reasoning.effort in xAI Responses requests; omitted by default. This also applies to Grok search selected by Jev. Unsupported reasoning values reported by the upstream API remain errors; the field is not silently removed and retried. The xAI connection test in `doctor` and the App sends the same `reasoning.effort` and `stream` as a search, without tools, and names them in its message and under `sent`; a stream that fails after HTTP 200 fails the test.
-- Neither OpenAI-compatible API mode sends xAI `web_search` / `x_search` tools or legacy `search_parameters`; xAI Chat Completions Live Search is deprecated.
+- OpenAI-compatible sends no search tools by default. `OPENAI_COMPATIBLE_TOOLS` (`web_search` or `web_search_preview`, comma-separated) attaches Responses tools to `search()` only; it requires `OPENAI_COMPATIBLE_API_MODE=responses`, and any other mode is a `parameter_error` on save and before a request. It never applies to `fetch()`, `describe_url()`, `rank_sources()`, synthesis, or the `doctor` connection test. `x_search` and legacy `search_parameters` are never sent; xAI Chat Completions Live Search is deprecated.
 - AnySearch is reported only as optional experimental `vertical_search`; it is not part of the `web_search` fallback and is not required by the `standard` minimum profile.
 - Sciverse is reported only as optional experimental explicit-only `vertical_search`; it is not `docs_search`, not part of default `search` / `research` fallback, and not required by the `standard` minimum profile.
 - Jina Reader is `web_fetch` only, not a general search provider. `JINA_API_KEY` is required before Jina satisfies the standard minimum profile; anonymous `r.jina.ai` is explicit/experimental fetch behavior.
@@ -138,6 +138,7 @@ OpenAI-compatible streaming:
 
 - `OPENAI_COMPATIBLE_API_MODE` defaults to `chat-completions` and accepts only `chat-completions` or `responses`. The selected protocol applies consistently to `search()`, provider-side `fetch()`, `describe_url()`, `rank_sources()`, `doctor`, and `diagnose openai-compatible`.
 - Responses mode handles the official `model` + `instructions`/`input` subset, heterogeneous `output` text parts, URL citations, typed stream deltas, and terminal failures. It does not promise `/responses` support from every relay marketed as OpenAI-compatible; accept each named relay with both diagnose stream probes.
+- Models that search only through the Responses `web_search` tool, such as `gpt-6.1-sol` on the official OpenAI API, need `OPENAI_COMPATIBLE_API_MODE=responses` plus `OPENAI_COMPATIBLE_TOOLS=web_search`. Chat Completions search models such as `gpt-5-search-api` search on their own; their `url_citation` annotations become structured sources. `diagnose openai-compatible` sends the configured tools with its search-shape and web-search probes.
 - `OPENAI_COMPATIBLE_STREAM` defaults to `false` and accepts `true`, `1`, or `yes` as true.
 - For OpenAI-compatible search, `search --stream` means "prefer stream first"; stream empty/timeout/retryable protocol failures fall back to the same provider/model with `stream=false`.
 - `search --no-stream` forces `stream=false` for the current invocation.

package/runtime/smart-search/_internal/smart_search/assets/skills/smart-search-cli/references/setup-config.md

@@ -84,6 +84,7 @@
 - Use `smart-search setup --non-interactive --jina-key "key"` to let Jina satisfy `web_fetch`; `JINA_RESPOND_WITH=readerlm-v2` also requires `JINA_API_KEY`.
 - Use `smart-search setup --non-interactive --zhipu-mcp-key "key"` only when the user explicitly wants Coding Plan Remote MCP quota.
 - Use `smart-search setup --non-interactive --openai-compatible-api-mode responses` only when a named relay requires `/responses`. The default is `chat-completions` and uses `/chat/completions`; invalid modes fail before setup saves any field.
+- Use `smart-search setup --non-interactive --openai-compatible-api-mode responses --openai-compatible-tools web_search` when the model searches only through the Responses `web_search` tool, such as `gpt-6.1-sol` with an official OpenAI key. Use `web_search_preview` for a relay that only knows the older name. Tools without `responses` mode fail before setup saves any field.
 - Use `smart-search setup --non-interactive --openai-compatible-stream true` only when an OpenAI-compatible relay benefits from SSE streaming for long requests. Default remains false.
 - Use `smart-search setup --non-interactive --openai-compatible-fallback-models "model-a,model-b"` to save ordered OpenAI-compatible backup models for primary model hard failure. These models do not receive a reserved time slice; the primary model keeps the remaining shared main-search budget. `--fallback off` and `search --model MODEL` disable this model fallback for one invocation.
 - Use `smart-search setup --non-interactive --search-timeout 300` or `smart-search config set SMART_SEARCH_TIMEOUT_SECONDS 300` to persist the normal search budget. Invalid non-positive values fail before provider work.

package/runtime/smart-search/_internal/smart_search/cli.py

@@ -869,6 +869,8 @@ def _format_model_markdown(data: dict[str, Any]) -> str:
         rows.append(["openai-compatible", data.get("openai_compatible_model")])
     if data.get("openai_compatible_api_mode"):
         rows.append([tr('openai-compatible API mode'), data.get("openai_compatible_api_mode")])
+    if data.get("openai_compatible_tools"):
+        rows.append([tr('openai-compatible tools'), ", ".join(data["openai_compatible_tools"])])
     fallback_models = data.get("openai_compatible_fallback_models") or []
     if fallback_models:
         rows.append([tr('openai-compatible fallback'), ", ".join(fallback_models)])
@@ -2337,6 +2339,7 @@ def _run_advanced_setup_prompts(values: dict[str, str], current: dict[str, str],
         ("OPENAI_COMPATIBLE_MODEL", "OpenAI-compatible model", True),
         ("OPENAI_COMPATIBLE_FALLBACK_MODELS", "OpenAI-compatible fallback models (comma-separated)", True),
         ("OPENAI_COMPATIBLE_API_MODE", "OpenAI-compatible API mode (chat-completions/responses)", True),
+        ("OPENAI_COMPATIBLE_TOOLS", "OpenAI-compatible Responses tools (web_search; needs API mode responses)", True),
         ("OPENAI_COMPATIBLE_STREAM", "OpenAI-compatible stream mode (true/false)", True),
         ("SMART_SEARCH_JEV_SYNTHESIS_API_URL", "JEV synthesis API URL", True),
         ("SMART_SEARCH_JEV_SYNTHESIS_API_KEY", "JEV synthesis API key", True),
@@ -2770,6 +2773,7 @@ def _run_setup(args: argparse.Namespace) -> int:
         "OPENAI_COMPATIBLE_MODEL": args.openai_compatible_model,
         "OPENAI_COMPATIBLE_FALLBACK_MODELS": args.openai_compatible_fallback_models,
         "OPENAI_COMPATIBLE_API_MODE": args.openai_compatible_api_mode,
+        "OPENAI_COMPATIBLE_TOOLS": args.openai_compatible_tools,
         "OPENAI_COMPATIBLE_STREAM": args.openai_compatible_stream,
         "SMART_SEARCH_JEV_SYNTHESIS_API_URL": args.jev_synthesis_api_url,
         "SMART_SEARCH_JEV_SYNTHESIS_API_KEY": args.jev_synthesis_api_key,
@@ -2844,20 +2848,28 @@ def _run_setup(args: argparse.Namespace) -> int:
 
     # Validate all local enum/numeric constraints before persisting any setup
     # field, so an invalid API mode cannot leave a partial provider profile.
-    for key, value in values.items():
-        if not value:
-            continue
-        try:
-            service.config._validate_config_value(key, value)
-        except ValueError as e:
-            data = {
-                "ok": False,
-                "error_type": "parameter_error",
-                "error": str(e),
-                "config_file": service.config_path()["config_file"],
-                "saved": {},
-            }
-            return _print_result("setup", data, args.format, args.output)
+    def validate_before_saving() -> None:
+        for key, value in values.items():
+            if value:
+                service.config._validate_config_value(key, value)
+        # Tools and API mode are saved one key at a time below, so check the pair up front.
+        if values.get("OPENAI_COMPATIBLE_TOOLS") or values.get("OPENAI_COMPATIBLE_API_MODE"):
+            service.config.check_openai_compatible_tools_mode(
+                values.get("OPENAI_COMPATIBLE_TOOLS") or service.config.openai_compatible_tools_raw,
+                values.get("OPENAI_COMPATIBLE_API_MODE") or service.config._get_config_value("OPENAI_COMPATIBLE_API_MODE", "") or "",
+            )
+
+    try:
+        validate_before_saving()
+    except ValueError as e:
+        data = {
+            "ok": False,
+            "error_type": "parameter_error",
+            "error": str(e),
+            "config_file": service.config_path()["config_file"],
+            "saved": {},
+        }
+        return _print_result("setup", data, args.format, args.output)
 
     saved: dict[str, str] = {}
     for key, value in values.items():
@@ -3469,6 +3481,7 @@ def build_parser() -> argparse.ArgumentParser:
     setup_parser.add_argument("--openai-compatible-model", default="", help="Save OPENAI_COMPATIBLE_MODEL.")
     setup_parser.add_argument("--openai-compatible-fallback-models", default="", help="Save OPENAI_COMPATIBLE_FALLBACK_MODELS.")
     setup_parser.add_argument("--openai-compatible-api-mode", default="", help="Save OPENAI_COMPATIBLE_API_MODE (chat-completions or responses).")
+    setup_parser.add_argument("--openai-compatible-tools", default="", help="Save OPENAI_COMPATIBLE_TOOLS (web_search or web_search_preview; needs --openai-compatible-api-mode responses).")
     setup_parser.add_argument("--openai-compatible-stream", default="", help="Save OPENAI_COMPATIBLE_STREAM.")
     setup_parser.add_argument("--jev-synthesis-api-url", default="", help="Save SMART_SEARCH_JEV_SYNTHESIS_API_URL.")
     setup_parser.add_argument("--jev-synthesis-api-key", default="", help="Save SMART_SEARCH_JEV_SYNTHESIS_API_KEY.")

package/runtime/smart-search/_internal/smart_search/config.py

@@ -37,6 +37,8 @@ class Config:
     _ALLOWED_XAI_TOOLS = {"web_search", "x_search"}
     _ALLOWED_XAI_REASONING_EFFORTS = {"low", "medium", "high"}
     _ALLOWED_OPENAI_COMPATIBLE_API_MODES = {"chat-completions", "responses"}
+    # Responses tools the OpenAI-compatible channel may attach to search(); empty sends none.
+    _ALLOWED_OPENAI_COMPATIBLE_TOOLS = {"web_search", "web_search_preview"}
     _ALLOWED_VALIDATION_LEVELS = {"fast", "balanced", "strict"}
     _ALLOWED_FALLBACK_MODES = {"auto", "off"}
     _ALLOWED_MINIMUM_PROFILES = {"standard", "off"}
@@ -77,6 +79,7 @@ class Config:
         "OPENAI_COMPATIBLE_MODEL",
         "OPENAI_COMPATIBLE_FALLBACK_MODELS",
         "OPENAI_COMPATIBLE_API_MODE",
+        "OPENAI_COMPATIBLE_TOOLS",
         "OPENAI_COMPATIBLE_STREAM",
         "SMART_SEARCH_VALIDATION_LEVEL",
         "SMART_SEARCH_FALLBACK_MODE",
@@ -166,6 +169,7 @@ class Config:
         "OPENAI_COMPATIBLE_MODEL",
         "OPENAI_COMPATIBLE_FALLBACK_MODELS",
         "OPENAI_COMPATIBLE_API_MODE",
+        "OPENAI_COMPATIBLE_TOOLS",
         "OPENAI_COMPATIBLE_STREAM",
         "SMART_SEARCH_VALIDATION_LEVEL",
         "SMART_SEARCH_FALLBACK_MODE",
@@ -521,6 +525,15 @@ class Config:
                     for old_key, new_key in self._LEGACY_CONFIG_KEYS.items():
                         if new_key == key:
                             config_data.pop(old_key, None)
+                if {"OPENAI_COMPATIBLE_TOOLS", "OPENAI_COMPATIBLE_API_MODE"} & (set(normalized_set) | set(normalized_unset)):
+                    try:
+                        self.check_openai_compatible_tools_mode(
+                            str(config_data.get("OPENAI_COMPATIBLE_TOOLS") or ""),
+                            str(config_data.get("OPENAI_COMPATIBLE_API_MODE") or ""),
+                        )
+                    except ValueError as e:
+                        return {"ok": False, "errors": [{"key": "OPENAI_COMPATIBLE_TOOLS", "error": str(e)}],
+                                "saved": [], "unset": []}
                 self._save_config_file(config_data)
         except OSError:
             raise ValueError(tr('无法锁定或保存配置文件，请检查权限或稍后重试。')) from None
@@ -642,27 +655,55 @@ class Config:
     def openai_compatible_stream(self) -> bool:
         return (self._get_config_value("OPENAI_COMPATIBLE_STREAM", "false") or "false").lower() in ("true", "1", "yes")
 
-    def parse_xai_tools(self, raw: str | None = None) -> list[str]:
-        raw = raw or self.xai_tools_raw
+    @property
+    def openai_compatible_tools_raw(self) -> str:
+        return self._get_config_value("OPENAI_COMPATIBLE_TOOLS", "") or ""
+
+    @property
+    def openai_compatible_tools(self) -> list[str]:
+        """Tools attached to Responses search(); raises when they could never be sent."""
+        tools = self.parse_openai_compatible_tools(self.openai_compatible_tools_raw)
+        self.check_openai_compatible_tools_mode(",".join(tools), self.openai_compatible_api_mode)
+        return tools
+
+    def check_openai_compatible_tools_mode(self, tools_raw: str, api_mode: str) -> None:
+        """Tools ride on Responses requests only, so any other mode would silently drop them."""
+        tools, _ = self._split_tool_list(tools_raw, self._ALLOWED_OPENAI_COMPATIBLE_TOOLS)
+        if tools and (api_mode or self._DEFAULT_OPENAI_COMPATIBLE_API_MODE).strip().lower() != "responses":
+            raise ValueError(tr(
+                'OPENAI_COMPATIBLE_TOOLS only works with OPENAI_COMPATIBLE_API_MODE=responses. '
+                'Set the API mode to responses, or clear OPENAI_COMPATIBLE_TOOLS.'
+            ))
+
+    @staticmethod
+    def _split_tool_list(raw: str, allowed: set[str]) -> tuple[list[str], list[str]]:
         tools: list[str] = []
         invalid: list[str] = []
-        seen: set[str] = set()
-        for item in raw.split(","):
+        for item in (raw or "").split(","):
             tool = item.strip().lower()
             if not tool:
                 continue
-            if tool not in self._ALLOWED_XAI_TOOLS:
+            if tool not in allowed:
                 invalid.append(tool)
-                continue
-            if tool not in seen:
-                seen.add(tool)
+            elif tool not in tools:
                 tools.append(tool)
+        return tools, invalid
+
+    def parse_xai_tools(self, raw: str | None = None) -> list[str]:
+        tools, invalid = self._split_tool_list(raw or self.xai_tools_raw, self._ALLOWED_XAI_TOOLS)
         if invalid:
             allowed = ", ".join(sorted(self._ALLOWED_XAI_TOOLS))
             invalid_text = ", ".join(invalid)
             raise ValueError(tr('Invalid XAI_TOOLS: {0}. Supported values: {1}', invalid_text, allowed))
         return tools
 
+    def parse_openai_compatible_tools(self, raw: str | None) -> list[str]:
+        tools, invalid = self._split_tool_list(raw or "", self._ALLOWED_OPENAI_COMPATIBLE_TOOLS)
+        if invalid:
+            allowed = ", ".join(sorted(self._ALLOWED_OPENAI_COMPATIBLE_TOOLS))
+            raise ValueError(tr('Invalid OPENAI_COMPATIBLE_TOOLS: {0}. Supported values: {1}', ", ".join(invalid), allowed))
+        return tools
+
     def _validated_enum(self, key: str, default: str, allowed: set[str]) -> str:
         return self._validate_enum_value(key, self._get_config_value(key, default) or default, allowed)
 
@@ -742,6 +783,9 @@ class Config:
         if key == "XAI_TOOLS":
             self.parse_xai_tools(value or self._DEFAULT_XAI_TOOLS)
             return
+        if key == "OPENAI_COMPATIBLE_TOOLS":
+            self.parse_openai_compatible_tools(value)
+            return
         # Every getter below falls back to its default on an empty value, so an
         # empty string is how a key is cleared rather than a value to check.
         if not str(value).strip():
@@ -1225,6 +1269,12 @@ class Config:
             self._DEFAULT_OPENAI_COMPATIBLE_API_MODE,
             self._ALLOWED_OPENAI_COMPATIBLE_API_MODES,
         )
+        openai_compatible_tools = self.openai_compatible_tools_raw
+        try:
+            openai_compatible_tools = ",".join(self.openai_compatible_tools)
+        except ValueError as exc:
+            if not openai_compatible_api_mode_error:
+                config_parameter_errors.append(str(exc))
         primary_api_mode = tr('未配置')
         if xai_configured:
             primary_api_mode = "xai-responses"
@@ -1273,6 +1323,7 @@ class Config:
             "OPENAI_COMPATIBLE_MODEL": self.openai_compatible_model,
             "OPENAI_COMPATIBLE_FALLBACK_MODELS": ",".join(self.openai_compatible_fallback_models),
             "OPENAI_COMPATIBLE_API_MODE": openai_compatible_api_mode,
+            "OPENAI_COMPATIBLE_TOOLS": openai_compatible_tools,
             "OPENAI_COMPATIBLE_STREAM": self.openai_compatible_stream,
             "SMART_SEARCH_VALIDATION_LEVEL": validation_level,
             "SMART_SEARCH_FALLBACK_MODE": fallback_mode,

package/runtime/smart-search/_internal/smart_search/jev_search.py

@@ -678,6 +678,9 @@ async def search(
     error_type = "" if ok else (failure.error_type if failure else "timeout" if stopped == "deadline" else "evidence_error")
     error = "" if ok else (failure.error if failure else "Search deadline exhausted" if stopped == "deadline"
                            else "Search did not obtain enough verified useful evidence")
+    if not ok and not failure and stopped != "deadline" and validation == "strict" and evidence and not has_source_evidence(evidence):
+        # Only a search model's own citations came back; strict needs pages a search provider retrieved.
+        error = source_message('strict 校验需要搜索服务独立检索到的来源；这次只有搜索模型自带的引用，不算独立证据。配置一个 web_search 提供方（例如 Tavily、智谱、元宝搜索）后再用 strict，或改用 balanced。')
     if not ok and not evidence and terminal_error:
         error_type, error = terminal_error["error_type"], terminal_error.get("error", error)
     if stopped == "cancelled":

package/runtime/smart-search/_internal/smart_search/providers/openai_compatible.py

@@ -173,6 +173,7 @@ class OpenAICompatibleSearchProvider(BaseSearchProvider):
         model: str = "grok-4-fast",
         stream: bool = False,
         api_mode: str = "chat-completions",
+        tools: list[str] | None = None,
     ):
         super().__init__(normalize_openai_compatible_api_url(api_url), api_key)
         self.model = model
@@ -181,6 +182,8 @@ class OpenAICompatibleSearchProvider(BaseSearchProvider):
         if self.api_mode not in OPENAI_COMPATIBLE_API_MODES:
             allowed = ", ".join(sorted(OPENAI_COMPATIBLE_API_MODES))
             raise ValueError(source_message('Invalid OpenAI-compatible API mode: {0}. Supported values: {1}', self.api_mode, allowed))
+        # Responses tools such as web_search, sent with search() only (OPENAI_COMPATIBLE_TOOLS).
+        self.tools = list(tools or [])
         self.last_transport_attempts: list[dict[str, Any]] = []
         self._search_deadline_monotonic: float | None = None
 
@@ -263,6 +266,13 @@ class OpenAICompatibleSearchProvider(BaseSearchProvider):
             ]
         return payload
 
+    def _build_search_payload(self, instructions: str, user_content: str, *, stream: bool) -> dict[str, Any]:
+        """The search request; the only one that may carry Responses tools."""
+        payload = self._build_request_payload(instructions, user_content, stream=stream)
+        if self.api_mode == "responses" and self.tools:
+            payload["tools"] = [{"type": tool} for tool in self.tools]
+        return payload
+
     async def search(self, query: str, platform: str = "", ctx=None) -> List[SearchResult]:
         headers = self._build_api_headers()
         platform_prompt = ""
@@ -272,7 +282,7 @@ class OpenAICompatibleSearchProvider(BaseSearchProvider):
 
         time_context = get_local_time_info() + "\n"
 
-        payload = self._build_request_payload(
+        payload = self._build_search_payload(
             search_prompt,
             time_context + query + platform_prompt,
             stream=self.stream,
@@ -487,6 +497,7 @@ class OpenAICompatibleSearchProvider(BaseSearchProvider):
             return await self._parse_responses_streaming_response(response, ctx)
 
         content = ""
+        sources: list[dict] = []
         full_body_buffer = []
 
         async for line in response.aiter_lines():
@@ -507,6 +518,8 @@ class OpenAICompatibleSearchProvider(BaseSearchProvider):
                         delta = choices[0].get("delta", {})
                         if "content" in delta:
                             content += delta["content"]
+                        if isinstance(delta, dict) and delta.get("annotations"):
+                            sources = self._merge_citations(sources, self._normalize_chat_annotations(delta["annotations"]))
                 except (json.JSONDecodeError, IndexError):
                     continue
 
@@ -517,9 +530,11 @@ class OpenAICompatibleSearchProvider(BaseSearchProvider):
                 if "choices" in data and len(data["choices"]) > 0:
                     message = data["choices"][0].get("message", {})
                     content = message.get("content", "")
+                    sources = self._merge_citations(sources, self._extract_citations(data))
             except json.JSONDecodeError:
                 pass
 
+        content = self._append_sources(content, sources)
         await log_info(ctx, f"content: {content}", config.debug_enabled)
 
         return content
@@ -857,9 +872,24 @@ class OpenAICompatibleSearchProvider(BaseSearchProvider):
                 continue
             message = choice.get("message")
             if isinstance(message, dict):
-                sources = self._merge_citations(sources, self._normalize_citations(message.get("citations")))
+                sources = self._merge_citations(
+                    sources,
+                    self._normalize_citations(message.get("citations")),
+                    self._normalize_chat_annotations(message.get("annotations")),
+                )
         return sources
 
+    def _normalize_chat_annotations(self, annotations: Any) -> list[dict]:
+        """Chat Completions search models nest each citation: {"type": "url_citation", "url_citation": {...}}."""
+        if not isinstance(annotations, list):
+            return []
+        citations = [
+            item.get("url_citation") if isinstance(item.get("url_citation"), dict) else item
+            for item in annotations
+            if isinstance(item, dict) and item.get("type") == "url_citation"
+        ]
+        return self._normalize_citations(citations)
+
     def _normalize_responses_citations(self, citations: Any) -> list[dict]:
         if not citations:
             return []

package/runtime/smart-search/_internal/smart_search/providers/xai_responses.py

@@ -14,6 +14,7 @@ from .base import BaseSearchProvider
 from .openai_compatible import OpenAICompatibleSearchProvider, _StopAfterSlowFailure, _StopAtDeadline, _WaitWithRetryAfter, _is_retryable_exception, get_local_time_info
 from ..config import config
 from ..logger import log_info
+from ..provider_errors import ProviderCallError
 from ..utils import search_prompt
 
 
@@ -115,7 +116,19 @@ class XAIResponsesSearchProvider(BaseSearchProvider):
     async def search(self, query: str, platform: str = "", ctx=None) -> str:
         payload = self._build_search_payload(query, platform)
         await log_info(ctx, f"platform_prompt: {query}", config.debug_enabled)
-        return await self._execute_response_with_retry(self._build_api_headers(), payload, ctx)
+        try:
+            return await self._execute_response_with_retry(self._build_api_headers(), payload, ctx)
+        except httpx.HTTPStatusError as exc:
+            # The default XAI_TOOLS includes x_search, which only xAI serves; other Responses
+            # services (OpenAI, most relays) answer 400. Say which setting to change.
+            if exc.response.status_code == 400 and "x_search" in self.tools and "x_search" in (exc.response.text or ""):
+                host = urlsplit(self.api_url).netloc or self.api_url
+                raise ProviderCallError(
+                    "parameter_error",
+                    source_message('{0} 不支持 XAI_TOOLS 里的 x_search（HTTP 400）。x_search 只有 xAI 官方接口能用；把 XAI_TOOLS 改成 web_search 再试。', host),
+                    additional_secrets=(self.api_key,),
+                ) from exc
+            raise
 
     async def _execute_response_with_retry(self, headers: dict, payload: dict, ctx=None) -> str:
         timeout = self._request_timeout()

package/runtime/smart-search/_internal/smart_search/service.py

@@ -1656,7 +1656,7 @@ def _main_search_provider_configs(model_override: str = "", providers: str = "au
             "model": model_override or config.openai_compatible_model,
             "fallback_models": [] if model_override else config.openai_compatible_fallback_models,
             "stream": config.openai_compatible_stream,
-            "tools": [],
+            "tools": config.openai_compatible_tools,
             "source": "OPENAI_COMPATIBLE_*",
         }
 
@@ -1690,6 +1690,7 @@ def _main_search_providers(provider_configs: list[dict[str, Any]], fallback: str
                     provider_config["model"],
                     provider_config.get("stream", False),
                     provider_config.get("api_mode", provider_config.get("mode", "chat-completions")),
+                    tools=provider_config.get("tools") or [],
                 )
             )
     return providers
@@ -2841,6 +2842,10 @@ def _diagnose_check_result(
     return result
 
 
+def _rate_limited(*checks: dict[str, Any]) -> bool:
+    return any(check.get("http_status") == 429 for check in checks)
+
+
 def _openai_compatible_diagnosis(quick: dict[str, Any], no_stream: dict[str, Any], stream: dict[str, Any]) -> tuple[bool, str, str]:
     quick_ok = quick.get("status") == "ok"
     no_stream_ok = no_stream.get("status") == "ok"
@@ -2853,6 +2858,12 @@ def _openai_compatible_diagnosis(quick: dict[str, Any], no_stream: dict[str, Any
             source_message('OpenAI-compatible 主链路正常。'),
             source_message('真实 search 形态的 stream=false 和 stream=true 都能返回。若用户仍卡住，更可能是调用方、PATH、超时设置或上游偶发波动。'),
         )
+    if _rate_limited(quick, no_stream, stream):
+        return (
+            False,
+            source_message('OpenAI-compatible 被上游限流（HTTP 429），这次诊断判断不了链路是否正常。'),
+            source_message('等一分钟再运行本诊断；经常出现就降低并发、换模型，或提高账户的速率额度。地址、key 和模型名不一定有问题。'),
+        )
     if stream_ok and not no_stream_ok:
         return (
             False,
@@ -2892,11 +2903,12 @@ async def _probe_openai_compatible_search_shape(
     stream: bool,
     timeout_seconds: float,
     api_mode: str = "chat-completions",
+    tools: list[str] | None = None,
 ) -> dict[str, Any]:
     name = f"真实 {api_mode} search 请求 (stream={'true' if stream else 'false'})"
     start = time.time()
-    provider = OpenAICompatibleSearchProvider(api_url, api_key, model, stream=stream, api_mode=api_mode)
-    payload = provider._build_request_payload(search_prompt, get_local_time_info() + "\nping", stream=stream)
+    provider = OpenAICompatibleSearchProvider(api_url, api_key, model, stream=stream, api_mode=api_mode, tools=tools)
+    payload = provider._build_search_payload(search_prompt, get_local_time_info() + "\nping", stream=stream)
     headers = provider._build_api_headers()
     headers["User-Agent"] = "smart-search/diagnose"
     timeout = httpx.Timeout(connect=6.0, read=timeout_seconds, write=10.0, pool=None)
@@ -2996,10 +3008,11 @@ async def _probe_openai_compatible_web_search(
     api_mode: str,
     stream: bool,
     timeout_seconds: float,
+    tools: list[str] | None = None,
 ) -> dict:
     name = "联网搜索能力"
     start = time.time()
-    provider = OpenAICompatibleSearchProvider(api_url, api_key, model, stream=stream, api_mode=api_mode)
+    provider = OpenAICompatibleSearchProvider(api_url, api_key, model, stream=stream, api_mode=api_mode, tools=tools)
     answer = ""
     try:
         content = await asyncio.wait_for(provider.search("What is the latest stable Python release? Cite the source URL."), timeout_seconds)
@@ -3026,16 +3039,15 @@ async def diagnose_openai_compatible(timeout_seconds: float = 30.0) -> dict[str,
     api_key = config.openai_compatible_api_key
     model = config.openai_compatible_model
     info = config.config_path_info()
-    try:
-        api_mode = config.openai_compatible_api_mode
-    except ValueError as e:
+
+    def invalid_config(error: Exception, configured_api_mode: str, summary: str, recommendation: str) -> dict[str, Any]:
         return {
             "ok": False,
             "provider": "openai-compatible",
             "api_url": api_url or "未配置",
             "api_key": config._mask_api_key(api_key) if api_key else "未配置",
             "model": model,
-            "configured_api_mode": "invalid",
+            "configured_api_mode": configured_api_mode,
             "configured_stream": config.openai_compatible_stream,
             "timeout_seconds": timeout_seconds,
             "config_file": info.get("config_file", ""),
@@ -3043,11 +3055,23 @@ async def diagnose_openai_compatible(timeout_seconds: float = 30.0) -> dict[str,
             "checks": [],
             "next_command": OPENAI_COMPATIBLE_DIAGNOSE_COMMAND,
             "error_type": "parameter_error",
-            "error": str(e),
-            "summary": source_message('OpenAI-compatible API mode is invalid.'),
-            "recommendation": source_message('Set OPENAI_COMPATIBLE_API_MODE to chat-completions or responses.'),
+            "error": str(error),
+            "summary": summary,
+            "recommendation": recommendation,
             "elapsed_ms": _elapsed_ms(start),
         }
+
+    try:
+        api_mode = config.openai_compatible_api_mode
+    except ValueError as e:
+        return invalid_config(e, "invalid", source_message('OpenAI-compatible API mode is invalid.'),
+                              source_message('Set OPENAI_COMPATIBLE_API_MODE to chat-completions or responses.'))
+    try:
+        tools = config.openai_compatible_tools
+    except ValueError as e:
+        return invalid_config(e, api_mode, source_message('OpenAI-compatible tools are invalid.'),
+                              source_message('Use OPENAI_COMPATIBLE_TOOLS=web_search (or web_search_preview) only with '
+                                             'OPENAI_COMPATIBLE_API_MODE=responses; otherwise leave it empty.'))
     endpoint = openai_compatible_endpoint(api_url or "", api_mode)
     result: dict[str, Any] = {
         "ok": False,
@@ -3056,6 +3080,7 @@ async def diagnose_openai_compatible(timeout_seconds: float = 30.0) -> dict[str,
         "api_key": config._mask_api_key(api_key) if api_key else "未配置",
         "model": model,
         "configured_api_mode": api_mode,
+        "configured_tools": tools,
         "endpoint": endpoint if api_url else "",
         "configured_stream": config.openai_compatible_stream,
         "timeout_seconds": timeout_seconds,
@@ -3104,18 +3129,21 @@ async def diagnose_openai_compatible(timeout_seconds: float = 30.0) -> dict[str,
         "has_content": bool(quick.get("has_content", quick.get("status") == "ok")),
     }
     result["checks"].append(quick_check)
-    probe_kwargs = {"stream": False, "timeout_seconds": timeout_seconds}
+    # Probes send what a real search sends, tools included; the quick check above never does.
+    tool_kwargs = {"tools": tools} if tools else {}
+    probe_kwargs = {"stream": False, "timeout_seconds": timeout_seconds, **tool_kwargs}
     if api_mode != "chat-completions":
         probe_kwargs["api_mode"] = api_mode
     no_stream = await _probe_openai_compatible_search_shape(api_url, api_key, model, **probe_kwargs)
     result["checks"].append(no_stream)
-    probe_kwargs = {"stream": True, "timeout_seconds": timeout_seconds}
+    probe_kwargs = {"stream": True, "timeout_seconds": timeout_seconds, **tool_kwargs}
     if api_mode != "chat-completions":
         probe_kwargs["api_mode"] = api_mode
     stream = await _probe_openai_compatible_search_shape(api_url, api_key, model, **probe_kwargs)
     result["checks"].append(stream)
     web = await _probe_openai_compatible_web_search(api_url, api_key, model, api_mode=api_mode,
-                                                   stream=config.openai_compatible_stream, timeout_seconds=timeout_seconds)
+                                                   stream=config.openai_compatible_stream, timeout_seconds=timeout_seconds,
+                                                   **tool_kwargs)
     result["checks"].append(web)
     result["web_search_capable"] = web["status"] == "ok"
 
@@ -3144,14 +3172,18 @@ async def diagnose_openai_compatible(timeout_seconds: float = 30.0) -> dict[str,
     result["timeout_policy"] = OPENAI_COMPATIBLE_TIMEOUT_POLICY
 
     ok, summary, recommendation = _openai_compatible_diagnosis(quick_check, no_stream, stream)
-    if web["status"] != "ok":
-        recommendation = source_message('{0} 另外，联网搜索能力检查未通过：{1}。OpenAI-compatible 不会发送搜索工具；如果该模型只能通过 Responses 的 web_search 工具联网，请把 XAI_API_URL、XAI_API_KEY、XAI_MODEL 指向支持 /v1/responses 的中转站。', recommendation, web['message'])
+    # Under a rate limit the web probe fails for the same reason; its advice would mislead.
+    rate_limited = not ok and _rate_limited(quick_check, no_stream, stream)
+    if web["status"] != "ok" and not rate_limited and tools:
+        recommendation = source_message('{0} 另外，联网搜索能力检查未通过：{1}。请求里已经带了 {2} 工具，可能是这个模型或中转站不支持 Responses 的联网工具；换一个支持的模型，或清空 OPENAI_COMPATIBLE_TOOLS 改用自带搜索的模型。', recommendation, web['message'], ", ".join(tools))
+    elif web["status"] != "ok" and not rate_limited:
+        recommendation = source_message('{0} 另外，联网搜索能力检查未通过：{1}。如果这个模型只能通过 Responses 的 web_search 工具联网（例如 OpenAI 官方的 gpt-6.1-sol），请设置 OPENAI_COMPATIBLE_API_MODE=responses 和 OPENAI_COMPATIBLE_TOOLS=web_search；中转站只认旧名时改用 web_search_preview。', recommendation, web['message'])
     if inventory.get("status") == "warning":
         recommendation = source_message('{0} 另外，{1}。兜底只在主模型硬失败后接力，不会再把主模型砍成 30 秒。', recommendation, inventory['message'])
     result.update(
         {
             "ok": ok,
-            "error_type": "" if ok else "network_error",
+            "error_type": "" if ok else "rate_limited" if rate_limited else "network_error",
             "error": "" if ok else summary,
             "summary": summary,
             "recommendation": recommendation,
@@ -3906,6 +3938,7 @@ async def doctor() -> dict[str, Any]:
 def current_model() -> dict[str, Any]:
     try:
         api_mode = config.openai_compatible_api_mode
+        tools = config.openai_compatible_tools
     except ValueError as e:
         return {
             "ok": False,
@@ -3920,6 +3953,7 @@ def current_model() -> dict[str, Any]:
         "openai_compatible_model": config.openai_compatible_model,
         "openai_compatible_fallback_models": config.openai_compatible_fallback_models,
         "openai_compatible_api_mode": api_mode,
+        "openai_compatible_tools": tools,
         "config_file": str(config.config_file),
     }
 

package/runtime/smart-search/_internal/smart_search/sources.py

@@ -13,6 +13,9 @@ from .utils import NO_WEB_SEARCH_MARKER, extract_unique_urls
 
 _MD_LINK_PATTERN = re.compile(r"\[([^\]]+)\]\((https?://[^)]+)\)")
 _INLINE_CITATION_LINK_PATTERN = re.compile(r"\[\[(\d+)\]\]\((https?://[^)]+)\)")
+# How OpenAI search models cite at the end of a sentence or bullet: "... in 2026. ([python.org](https://...))"
+_PARENTHESIZED_CITATION_PATTERN = re.compile(r"[(（]\s*\[[^\]]+\]\(https?://[^)\s]+\)\s*[)）]")
+_BARE_OR_ANGLE_URL_PATTERN = re.compile(r"<?https?://[^\s>]+>?")
 _SOURCES_HEADING_PATTERN = re.compile(
     r"(?im)^"
     r"(?:#{1,6}\s*)?"
@@ -338,11 +341,20 @@ def _is_link_only_line(line: str) -> bool:
         return False
     if stripped.startswith(("http://", "https://")):
         return True
+    citation = _PARENTHESIZED_CITATION_PATTERN.search(stripped)
+    if citation and _has_prose(stripped[: citation.start()]):
+        # A sentence that ends with its citation belongs to the answer, not to a trailing source list.
+        return False
     if _MD_LINK_PATTERN.search(stripped):
         return True
     return False
 
 
+def _has_prose(text: str) -> bool:
+    text = _BARE_OR_ANGLE_URL_PATTERN.sub("", _MD_LINK_PATTERN.sub("", text))
+    return re.search(r"[^\W\d_]", text) is not None
+
+
 def _parse_sources_payload(payload: str) -> list[dict]:
     payload = (payload or "").strip().rstrip(";")
     if not payload:

package/runtime/smart-search/_internal/smart_search/ui_metadata.py

@@ -198,11 +198,20 @@ CONFIG_FIELDS: tuple[ConfigField, ...] = (
        provider="openai-compatible", capabilities=("main_search",)),
     _f(key="OPENAI_COMPATIBLE_API_MODE", section="getting_started", tier="advanced", kind="enum",
        label_zh="接口模式", label_en="API mode",
-       help_zh="大多数服务用 chat-completions。",
-       help_en="Most services want chat-completions.",
+       help_zh="大多数服务用 chat-completions。要让 gpt-6.1-sol 这类只在 Responses 里联网的模型搜索，选 responses，再在下面的联网工具填 web_search。",
+       help_en="Most services want chat-completions. For models such as gpt-6.1-sol that only search through Responses, choose responses and set the tools below to web_search.",
        default=Config._DEFAULT_OPENAI_COMPATIBLE_API_MODE,
        choices=tuple(sorted(Config._ALLOWED_OPENAI_COMPATIBLE_API_MODES)),
        provider="openai-compatible", capabilities=("main_search",)),
+    # A plain text field on purpose, with no `choices`: the Windows App draws any field with choices as a closed
+    # dropdown, preselects the first choice when the saved value is not one of them (an empty value never is),
+    # and counts that preselection as "unchanged". Empty could not be shown and web_search could not be saved.
+    _f(key="OPENAI_COMPATIBLE_TOOLS", section="getting_started", tier="advanced", kind="csv",
+       label_zh="联网工具", label_en="Responses tools",
+       help_zh="留空表示不发送工具。只在接口模式为 responses 时可用，只随搜索请求发送。用 OpenAI 官方 key 跑 gpt-6.1-sol 这类模型要联网，填 web_search；中转站只认旧名时填 web_search_preview；模型自带搜索（如 gpt-5-search-api）保持留空。",
+       help_en="Leave empty to send no tool. Only with API mode responses, and sent with search requests only. Enter web_search to let models such as gpt-6.1-sol search with an official OpenAI key; enter web_search_preview for relays that only know the older name; keep it empty for models that search on their own, such as gpt-5-search-api.",
+       placeholder="web_search",
+       provider="openai-compatible", capabilities=("main_search",)),
     _f(key="OPENAI_COMPATIBLE_STREAM", section="getting_started", tier="advanced", kind="bool",
        label_zh="流式返回", label_en="Stream responses",
        help_zh="部分服务只在流式下才肯长时间思考。", help_en="Some services only think for long under streaming.",

package/runtime/smart-search/_internal/smart_search/utils.py

@@ -1,6 +1,10 @@
-from typing import List
+from typing import TYPE_CHECKING, List
 import re
-from .providers.base import SearchResult
+
+if TYPE_CHECKING:
+    # A runtime import would load providers/__init__.py, whose providers import this
+    # module back: importing smart_search.sources first then fails halfway.
+    from .providers.base import SearchResult
 
 _URL_PATTERN = re.compile(r'https?://[^\s<>"\'`，。、；：！？》）】\)]+')
 
@@ -52,7 +56,7 @@ def format_extra_sources(tavily_results: list[dict] | None, firecrawl_results: l
     return "\n\n".join(sections)
 
 
-def format_search_results(results: List[SearchResult]) -> str:
+def format_search_results(results: List["SearchResult"]) -> str:
     if not results:
         return "No results found."
 

package/runtime/smart-search/_internal/{smart_search-0.1.32.dist-info → smart_search-0.1.34.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: smart-search
-Version: 0.1.32
+Version: 0.1.34
 Summary: CLI-first multi-source web research with xAI/OpenAI-compatible search, Exa, Context7, Zhipu, Tavily, Firecrawl, and Deep Research planning.
 Requires-Python: >=3.10
 Description-Content-Type: text/markdown

package/runtime/smart-search/_internal/{smart_search-0.1.32.dist-info → smart_search-0.1.34.dist-info}/RECORD

@@ -1,13 +1,13 @@
 ../../../bin/smart-search,sha256=q9upy4clf9uCDMAJIt-pBkuMwhZ7KupZeJLPO-SMjG4,206
-smart_search-0.1.32.dist-info/INSTALLER,sha256=zuuue4knoyJ-UwPPXg8fezS7VCrXJQrAP7zeNuwvFQg,4
-smart_search-0.1.32.dist-info/METADATA,sha256=qmcpDJFjrG5h-22--FHugd1BJdcmiCC7YSeg-kBif_k,19724
-smart_search-0.1.32.dist-info/RECORD,,
-smart_search-0.1.32.dist-info/REQUESTED,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-smart_search-0.1.32.dist-info/WHEEL,sha256=mOdXR9C3wMVov7cSY8PY-XCzo3SmmWCHvGQr5csJoao,91
-smart_search-0.1.32.dist-info/direct_url.json,sha256=uxzJhtkKbMt-CGh9XSoaSD7MmHAe_3DVycaTwRP2IhQ,76
-smart_search-0.1.32.dist-info/entry_points.txt,sha256=fiHguhz7hQ6ybeepO0OPpZm19XCi2J-Bkigf8DGBuKM,55
-smart_search-0.1.32.dist-info/licenses/LICENSE,sha256=o_zbH827gkTiZfsNLJGQn1z8Z4eLAvb8heFaSqSGVv8,1067
-smart_search-0.1.32.dist-info/top_level.txt,sha256=mBPprcb_b3tBApeRa2nlLaGj3UVNxXCdyz6QQvDzJpc,13
+smart_search-0.1.34.dist-info/INSTALLER,sha256=zuuue4knoyJ-UwPPXg8fezS7VCrXJQrAP7zeNuwvFQg,4
+smart_search-0.1.34.dist-info/METADATA,sha256=uJ3uNzgvo0uQucn9VGLkewJIwG_CMrfEumNZPM5l6Q8,19724
+smart_search-0.1.34.dist-info/RECORD,,
+smart_search-0.1.34.dist-info/REQUESTED,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+smart_search-0.1.34.dist-info/WHEEL,sha256=mOdXR9C3wMVov7cSY8PY-XCzo3SmmWCHvGQr5csJoao,91
+smart_search-0.1.34.dist-info/direct_url.json,sha256=uxzJhtkKbMt-CGh9XSoaSD7MmHAe_3DVycaTwRP2IhQ,76
+smart_search-0.1.34.dist-info/entry_points.txt,sha256=fiHguhz7hQ6ybeepO0OPpZm19XCi2J-Bkigf8DGBuKM,55
+smart_search-0.1.34.dist-info/licenses/LICENSE,sha256=o_zbH827gkTiZfsNLJGQn1z8Z4eLAvb8heFaSqSGVv8,1067
+smart_search-0.1.34.dist-info/top_level.txt,sha256=mBPprcb_b3tBApeRa2nlLaGj3UVNxXCdyz6QQvDzJpc,13
 smart_search/__init__.py,sha256=da1PTClDMl-IBkrSvq6JC1lnS-K_BASzCvxVhNxN5Ls,13
 smart_search/__pycache__/__init__.cpython-313.pyc,,
 smart_search/__pycache__/activity.cpython-313.pyc,,
@@ -40,19 +40,19 @@ smart_search/__pycache__/ui_metadata.cpython-313.pyc,,
 smart_search/__pycache__/ui_server.cpython-313.pyc,,
 smart_search/__pycache__/utils.cpython-313.pyc,,
 smart_search/activity.py,sha256=66yPPAfuaDSF4UTEuRRDefp2m1-l8eVnr8K5_ShoQCU,13368
-smart_search/assets/i18n/messages.json,sha256=Z0M41dCaUUYZfQY8hMNIBTjJjtNMAVgFootXQEJ76aY,643411
-smart_search/assets/skills/smart-search-cli/SKILL.md,sha256=465CCVKGCHfiJLDD9LlYbIhlbxWucwLiNVVAcRRlEf8,8561
+smart_search/assets/i18n/messages.json,sha256=4ovku0BT4KouTk0g58b_jX3RqXvBDFlWFxDo-DSGI38,653887
+smart_search/assets/skills/smart-search-cli/SKILL.md,sha256=gQ5HpNRnZ7VVYCu_MnyfAla62vQA2m6wl6mlvjfNLo8,8736
 smart_search/assets/skills/smart-search-cli/agents/openai.yaml,sha256=4S1VuEER7Puw9JvxDsyI__Tdrr1j2h6aF26yHho_x8E,162
 smart_search/assets/skills/smart-search-cli/references/cli-contract.md,sha256=mZyQRioJ4_ySkxcl9WQBMGXk5fcWOEMBMnXXUGnRoEA,1843
-smart_search/assets/skills/smart-search-cli/references/cli-core.md,sha256=aqUFtSDCfzB0StrxqnmeFUfE12roXGCMHtVHf3nIxLQ,15182
-smart_search/assets/skills/smart-search-cli/references/command-patterns.md,sha256=Io6DExbu4pSDz7-r51hyYtjd80CndCR8N7Q0XoEV9L4,12714
+smart_search/assets/skills/smart-search-cli/references/cli-core.md,sha256=QusO29X5_psX-K2I67rUlz3cMqyuOyFZU6MnWIMMJ0Y,15240
+smart_search/assets/skills/smart-search-cli/references/command-patterns.md,sha256=TC3HCEgTwrQf1w5AbmhhPqJRpCJHyyf9jTpCmfdy3WE,12902
 smart_search/assets/skills/smart-search-cli/references/deep-research-mode.md,sha256=Yt1qHQnbpKgA6P5PTXwv4qFDZTJn7MqarZvCqlmCg-0,14485
-smart_search/assets/skills/smart-search-cli/references/provider-routing.md,sha256=JVWHguq7OgguoNiV0Xr7Ay5g893saQPjNKp4QKGB7Ys,29423
+smart_search/assets/skills/smart-search-cli/references/provider-routing.md,sha256=zSEOTKBpiIC_vTXCRTU5wiwcGmnGFzZbd_LgBjqdbko,30231
 smart_search/assets/skills/smart-search-cli/references/regression-release.md,sha256=SkOUwxpPm_HeBGlpUil5ybTBiwa-wAzt-765zw9kYqk,5673
-smart_search/assets/skills/smart-search-cli/references/setup-config.md,sha256=KpEOBLkoV0GZZ6PHRV0G3RUgbFilZlSguhcwy03GHVc,18587
+smart_search/assets/skills/smart-search-cli/references/setup-config.md,sha256=lqXOSoIs0dGV7uamLeEvaLHX0MNQoMNmuKIyvFFEcuw,18964
 smart_search/assets/ui/index.html,sha256=i3se6JX5iHnGXIEXhHvLKZgPzNh8JMJAeRqfIlqac3U,63800
-smart_search/cli.py,sha256=QQk86ZqKqhK0xFuENCtUC3zAramfXzNUdOk5kBVRg80,168553
-smart_search/config.py,sha256=61Cp0UJiz1AD34ef80pQf1QnSz5w5zDbi458aUt8SxE,58275
+smart_search/cli.py,sha256=kA3-roJfQsIjPHj81aA-7qXcJLEDkdxPDrYBrTZP9-M,169589
+smart_search/config.py,sha256=hcK15frDWVyHFCrTMaejfM3cSPNO1ntkP0AOCfNm-tI,61256
 smart_search/desktop_backend.py,sha256=VYFc83YBllSljgbgx9oPPNbQLwGADZGVtN_CF08ShD8,42417
 smart_search/desktop_catalog.py,sha256=VMIsLFAD98Czetwy-ka606QnyUSk0gDBhsfz7k4QDl8,11485
 smart_search/desktop_cli.py,sha256=dpXLwf6b9Dgw9lKPTDZpKH1Z85OpIgrYyNJM2hXIu68,11069
@@ -64,7 +64,7 @@ smart_search/desktop_worker.py,sha256=Nkw_FMNNejrt8oJ6aNUmziSd7vVu_Xy9ijvfgstdaw
 smart_search/i18n.py,sha256=-mDfpi-P4AQPCUpnuI--W9c1AFurN5QPhAGYMXB02kU,4869
 smart_search/intent_router.py,sha256=UkFnv4R2xC6bF6QEn_lqSYqYOoWgoT_mXeG4CNcSJ3M,7931
 smart_search/jev.py,sha256=C80OBG2RMOJCMtogltVDHUg0xoCHO_8uIT69736myq8,27169
-smart_search/jev_search.py,sha256=k8V4xSXeIKraHTvDp2HDmbX2pPq5fTd-00n_FQwdPF0,49369
+smart_search/jev_search.py,sha256=k2e5nkmB3tx9wSU0784yAR3QiwsbUubqWh8y-DJiW3A,49881
 smart_search/logger.py,sha256=pwfjP50ywoTRirH4H7qYTNgt4TgoMhZlX2pb8dNvO9k,1203
 smart_search/provider_descriptions.py,sha256=PISS5lhXG4nLtr8xW8Y2_Okcc21SwSWPPTmdLOhsOfY,11027
 smart_search/provider_errors.py,sha256=IXyLo6Kc4WSP7faH5mMTQyAIVKR0BR0680qd0ZApKUo,5384
@@ -90,20 +90,20 @@ smart_search/providers/context7.py,sha256=zOImhEiKUVg60h9SbYdJRBSUfoVvS-8N6O62su
 smart_search/providers/deepseek.py,sha256=br_XHY0lc5xvgppp_4dPd_g5UU9jzEVCronn_UvyoH4,4678
 smart_search/providers/exa.py,sha256=6BLnSxDLM0PKXlkcqRKw49G728yBkRicDzQiJt2vIzo,6875
 smart_search/providers/jina.py,sha256=hz8KAcFSstWT4DIBWKdEhymYjBjUvo_SFeZcwCdPkTs,4048
-smart_search/providers/openai_compatible.py,sha256=CL-zuya3gx8-8_hGn7rTT5vXtubYKfnHe2aC2jzcSI0,41439
+smart_search/providers/openai_compatible.py,sha256=NmrEjO8vj6R_SDdQFAvv320DX2MLQg6NoEAFfhOwRVc,43120
 smart_search/providers/sciverse.py,sha256=kxhhkx4K08H7VGf4RWFdnB-dlmeEelDM2OcEwERTr8c,13567
 smart_search/providers/tinyfish.py,sha256=rdEjmPK_dDe-aD5M5sfJM6n2MA_uBuE2NVR6i7lKBqI,8446
-smart_search/providers/xai_responses.py,sha256=el6zfbZhGNMBKyhA2YtXWT1jmjsPEFStrTU41gi8sYU,10640
+smart_search/providers/xai_responses.py,sha256=PL_1SOMWKm6BWwWgdjMntdN_VoFckXly1ye8fr4gBQ8,11485
 smart_search/providers/yuanbao.py,sha256=CsbL1iEson5lAbIRyuv2Rai0Nm6LiHPZTq8WhL3wUbE,6357
 smart_search/providers/zhipu.py,sha256=PN0_Vc51rDYlxEmz2B1vgSxEt9jXf_RIsRobGp-LBPs,7088
 smart_search/providers/zhipu_mcp.py,sha256=4XgckrHzwSdhUtMlTSvhVxrAA7Fr7QX_4BYWfSHmXUg,10976
 smart_search/sciverse_schema.py,sha256=ml5iDXEpY7cnEMz74BGTo4yxX7UvPOe_i7w4Pi5t1wY,18178
-smart_search/service.py,sha256=ZTa3zFz1mkPVN33S-lfsOOq2FKlyUUqOyfeHAOaMGRc,195325
+smart_search/service.py,sha256=Viq6Of5jyB0XwQPAa_EOk8-J8gIpw7nyTGzaIgER4nk,197746
 smart_search/skill_installer.py,sha256=CvM9GQShaTR8ttNhilx8Up0vVsHZfsnYD5uM7wZrzBs,21782
 smart_search/skill_maintenance.py,sha256=2s2-1ZEEjRg2MfRKlaw6Y51OO86kOf9axl7fW6KMv0g,8818
-smart_search/sources.py,sha256=WvyRXqX_IdbDPpsqcSbulipxNtZvQbWv1MsZ2Ud5bTY,14376
+smart_search/sources.py,sha256=uGRPMZ9wnNrkkby4edQkPSwBxJfiyfgtaDdKsQ9rdTA,15067
 smart_search/state_files.py,sha256=K02dlR3Xuj2vIkRiEdrFr3OSiEsPxN5_HSo4NTmz0sc,2063
 smart_search/ui_api.py,sha256=p73zozirtzu7u8AQS4uWTCbsbomkbkxCExs_mE1_HW4,10043
-smart_search/ui_metadata.py,sha256=t_w-g2kP6HWCDbaE_LcoyRfHhwE5IT4bWsX1s1yYoCc,53939
+smart_search/ui_metadata.py,sha256=o1K1ZbPhHYyLF9mSDn5V0C6aM7WhC5Vf77Nofi1Seww,55433
 smart_search/ui_server.py,sha256=pcAPiYWmJXTmX1Xpy12v97JhkbRx-nJ3zRYefGW1Tc0,20508
-smart_search/utils.py,sha256=HVpxtyveEHcpGSkIObf97GbCJVRd68f1X6ecQeH14Ks,8992
+smart_search/utils.py,sha256=2b1Wy1Jk0loJ1MainS1N8WYjtMXwTQ9JlVOra3gYhEY,9193

package/runtime/smart-search/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@konbakuyomu/smart-search",
-  "version": "0.1.32",
+  "version": "0.1.34",
   "description": "CLI-first multi-source web research with xAI/OpenAI-compatible search, Exa, Context7, Zhipu, Tavily, Firecrawl, and Deep Research planning.",
   "license": "MIT",
   "homepage": "https://github.com/konbakuyomu/smartsearch#readme",
@@ -39,11 +39,11 @@
   },
   "smartSearchBinary": true,
   "optionalDependencies": {
-    "@konbakuyomu/smart-search-darwin-x64": "0.1.32",
-    "@konbakuyomu/smart-search-darwin-arm64": "0.1.32",
-    "@konbakuyomu/smart-search-win32-x64": "0.1.32",
-    "@konbakuyomu/smart-search-win32-arm64": "0.1.32",
-    "@konbakuyomu/smart-search-linux-x64": "0.1.32",
-    "@konbakuyomu/smart-search-linux-arm64": "0.1.32"
+    "@konbakuyomu/smart-search-darwin-x64": "0.1.34",
+    "@konbakuyomu/smart-search-darwin-arm64": "0.1.34",
+    "@konbakuyomu/smart-search-win32-x64": "0.1.34",
+    "@konbakuyomu/smart-search-win32-arm64": "0.1.34",
+    "@konbakuyomu/smart-search-linux-x64": "0.1.34",
+    "@konbakuyomu/smart-search-linux-arm64": "0.1.34"
   }
 }