diff --git a/CHANGELOG.md b/CHANGELOG.md
index 61bcdf5..96d9b4c 100644
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -1,5 +1,23 @@
 # Changelog
 
+## v2.6.5 — http_get 健壮性：编码嗅探 / 指数退避重试 / 二进制分流 / final_url
+
+- **http_get 编码嗅探**: 响应体解码从硬编码 UTF-8 改为三级嗅探（Content-Type charset → charset_normalizer → chardet，均为可选降级，兜底 UTF-8），修复 GBK/GB18030 中文站点静默乱码（`errors="replace"` 产生的 `` 属于"成功但内容全毁"的静默错误）。
+- **http_get 指数退避重试**: 新增 `_open_with_retry`，对 5xx 与连接错误（超时/断连）自动重试，默认 2 次、0.5s 起指数退避；4xx 与 SSRF 重定向拦截（安全决策）立即失败不重试。POST 非幂等，明确不重试以避免重复提交。
+- **http_get 二进制分流**: 响应 Content-Type 为 PDF/图片/音视频/压缩包等二进制类型时，不再把字节流当文本 decode 成乱码返回，改为明确报错并附 `hint` 引导改用 http_download。
+- **http_get 可观测性**: 返回新增 `final_url`（重定向后的落地地址，短链展开/跳转调试可用）与 `content_type` 字段，分页缓存条目同步携带。
+- **http_get 截断误报修复**: `_read_limited` 原 `total >= max_bytes` 在恰好等于上限时误报截断，改为多读 1 字节确认。
+- **http_get 翻页缓存前置（正确性）**: 原实现缓存检查在 HTTP 下载之后，翻页时整页重下再丢弃（缓存只省转换不省下载），且翻页瞬间对端宕机/限流时即使缓存完好也直接报错；现翻页请求先查缓存，命中零网络请求直接切片返回。
+- **http_get gzip/deflate 解压**: 自动广告 `Accept-Encoding: gzip, deflate` 并解压响应（服务器强制压缩时原会 decode 出乱码）；解压后再过一次 5MB 截断防压缩炸弹。
+- **http_get 脚本内容剔除**: markdownify 的 `strip` 只去标签不去文本，内联 `<script>/<style>` 源码原会泄漏进转换结果（SPA 页可泄漏数千字符 JS 浪费 token）；现转换前正则剔除整块。
+- **http_get SPA 检测**: 转换后几乎无文本但原始 HTML 含大量脚本时，返回附 `hint` 提示疑似 JS 动态渲染（本工具不执行 JS）并给出替代建议，不再让 LLM 面对"成功但空白"误判。
+- **http_get/http_post 错误可操作化**: HTTP 错误按状态码附排查 hint（401 认证 / 403 反爬 WAF / 404 失效 / 405 方法 / 429 限流 / 5xx 服务端），连接层错误区分 DNS 解析失败/超时（含当前 timeout 值）/拒连；自动重试后仍失败时透传 `retries` 次数；SSRF 拦截不再被"连接失败"前缀伪装成网络故障。
+- **http_get/http_post timeout clamp**: 直接调用也钳制到 1~600s（原仅注册表层对 post 生效），非法值回退默认。
+- **http_get review 修复（安全）**: ① 解压改 `zlib.decompressobj` 流式限长，压缩炸弹内存有界（原全量解压后才截断，1MB gzip 实测可撑 2GB）；② 翻页缓存 key 纳入 headers 规范化指纹，修复跨凭据缓存命中导致的机密内容泄露，`next_call` 同步透传 headers；③ script/style 剔除从正则改为线性扫描，修复大量无闭合标签构造的 O(n·m) DoS；④ SSRF 拦截改用专用异常 `SsrfBlocked`（原靠消息文案字符串匹配，脆弱耦合）。
+- **http_get review 修复（健壮性）**: `RemoteDisconnected`/`ConnectionResetError` 等非 URLError 连接错误纳入重试；offset 非整型返回错误而非 TypeError 泄漏；下载截断的压缩流返回已解压部分内容并标记（原静默返回压缩垃圾）；br/zstd 等不支持编码明确报错；HTTP 错误体读取限长 4KB；重试加总耗时预算（cap 180s，防大 timeout×重试放大）；重试前 close 失败响应；429 hint 与不重试行为对齐；自定义 UA/Accept-Encoding 大小写不敏感匹配；http_post 补二进制分流；编码嗅探只取前 64KB。
+- **测试修复**: 分页衔接断言原切片恒空（`startswith("")` 恒真）的假阳性改为与缓存全文比对；FakeResponse headers 改大小写不敏感（对齐真实 HTTPMessage）；GBK 嗅探 skip 守卫修正为任一嗅探库。
+- **db_query**: params schema 补 `items`（数组类型缺 items 导致 Gemini function calling 400 INVALID_ARGUMENT，43004d6）。
+
 ## v2.6.4 — 全量 code review 修复：响应协议 / 备份生命周期 / 行号寻址编辑 / CI 日志
 
 - **safe_edit 行号寻址**: 新增 `mode=insert_at_line`（`line` 后插入，`0`=文件开头）/ `delete_lines`（`start_line~end_line` 闭区间删除），走完整备份→语法检查→回滚链路；参数 `preserve_inner_indent` 更名 `align_whitespace`（语义不变）。
diff --git a/metadata.yaml b/metadata.yaml
index d9ffdfb..b2f285f 100644
--- a/metadata.yaml
+++ b/metadata.yaml
@@ -2,7 +2,7 @@ name: astrbot_plugin_irmia_devkit
 display_name: 弥亚开发工具箱
 desc: 为 Agent 提供实用且安全的开发工具 — 备份/语法检查/回滚，65 工具 + 1 Skill
 author: 伊尔弥亚
-version: 2.6.4
+version: 2.6.5
 repo: https://github.com/irmia2026/irmia_devkit_open
 short_desc: 安全代码编辑 — 备份/语法检查/回滚，65 工具 + 1 Skill
 astrbot_version: ">=4.16"
diff --git a/pyproject.toml b/pyproject.toml
index 6537a05..02f492b 100644
--- a/pyproject.toml
+++ b/pyproject.toml
@@ -1,6 +1,6 @@
 [project]
 name = "astrbot_plugin_irmia_devkit"
-version = "2.6.4"
+version = "2.6.5"
 description = "弥亚开发工具箱 — 为 LLM Agent 提供安全的代码开发工具集"
 requires-python = ">=3.10"
 
diff --git a/tests/test_http_get.py b/tests/test_http_get.py
index f6c94e0..35ac1e2 100644
--- a/tests/test_http_get.py
+++ b/tests/test_http_get.py
@@ -4,8 +4,13 @@
 Use monkeypatch to avoid actual HTTP calls.
 """
 
+import socket
+import urllib.error
 import urllib.request
 from io import BytesIO
+
+import pytest
+
 from tools.http_get import get, post
 
 
@@ -31,16 +36,33 @@ def _clear_cache():
     _page_cache.clear()
 
 
+class _CIDict(dict):
+    """模拟 email.message.Message 的大小写不敏感 get（真实响应头行为）。"""
+
+    def get(self, key, default=None):
+        key = key.lower()
+        for k, v in self.items():
+            if k.lower() == key:
+                return v
+        return default
+
+
 class FakeResponse:
     """模拟 urllib response 对象。"""
 
-    def __init__(self, body: bytes, status: int = 200):
+    def __init__(self, body: bytes, status: int = 200,
+                 headers: dict | None = None, url: str = ""):
         self._body = BytesIO(body)
         self.status = status
+        self.headers = _CIDict(headers or {})
+        self._url = url
 
     def read(self, n=-1):
         return self._body.read(n)
 
+    def geturl(self):
+        return self._url
+
     def __enter__(self):
         return self
 
@@ -228,7 +250,11 @@ def fake_open(self, req, timeout=None):
         assert r2["ok"] is True
         page2 = r2["content"]
         assert page1 != page2  # 内容不应相同
-        assert page2.startswith(page1[next_offset:next_offset + 20])  # 衔接正确
+        # 与缓存中的完整转换结果比对验证衔接（原断言切片恒为空串，是假阳性）
+        key = hg._cache_key("http://example.com", "markdown", False, None)
+        full = hg._page_cache[key]["content"]
+        assert page1 == full[:len(page1)]
+        assert page2 == full[next_offset:next_offset + len(page2)]
 
     def test_format_markdown_no_has_more(self, monkeypatch):
         """短内容不应标记 has_more。"""
@@ -304,3 +330,746 @@ def fake_open(self, req, timeout=None):
         r = post("http://example.com/api", data={"key": "value"})
         # mock 返回 200 响应
         assert r["ok"] is True
+
+
+# GBK 编码的中文页面，用于测试编码嗅探
+GBK_HTML = (
+    "<html><head><title>中文标题</title></head><body><p>"
+    + "这是一段用于测试编码嗅探的中文内容。" * 10
+    + "</p></body></html>"
+).encode("gbk")
+
+
+class TestCharsetDetection:
+    def test_gbk_via_content_type_header(self, monkeypatch):
+        """Content-Type 声明 charset=gbk 时应按 GBK 解码，不产生乱码。"""
+        from tools import http_get as hg
+
+        def fake_open(self, req, timeout=None):
+            return FakeResponse(
+                GBK_HTML, headers={"Content-Type": "text/html; charset=gbk"}
+            )
+
+        monkeypatch.setattr(hg, "make_opener", lambda: _fake_opener(fake_open))
+        r = get("http://example.com", format="markdown")
+        assert r["ok"] is True
+        assert "中文内容" in r["content"]
+        assert "\ufffd" not in r["content"]
+
+    def test_gbk_sniffed_without_charset_header(self, monkeypatch):
+        """无 charset 声明时由 chardet/charset_normalizer 嗅探兜底。"""
+        import importlib.util
+        if not (importlib.util.find_spec("charset_normalizer")
+                or importlib.util.find_spec("chardet")):
+            pytest.skip("需要 charset_normalizer 或 chardet")
+        from tools import http_get as hg
+
+        def fake_open(self, req, timeout=None):
+            return FakeResponse(GBK_HTML, headers={"Content-Type": "text/html"})
+
+        monkeypatch.setattr(hg, "make_opener", lambda: _fake_opener(fake_open))
+        r = get("http://example.com", format="markdown")
+        assert r["ok"] is True
+        assert "中文内容" in r["content"]
+
+    def test_invalid_charset_falls_back_to_utf8(self, monkeypatch):
+        """无法识别的 charset 名不应崩溃，回退 utf-8。"""
+        from tools import http_get as hg
+
+        def fake_open(self, req, timeout=None):
+            return FakeResponse(
+                SAMPLE_HTML.encode("utf-8"),
+                headers={"Content-Type": "text/html; charset=not-a-real-charset"},
+            )
+
+        monkeypatch.setattr(hg, "make_opener", lambda: _fake_opener(fake_open))
+        r = get("http://example.com", format="markdown")
+        assert r["ok"] is True
+        assert "Hello World" in r["content"]
+
+
+class TestBinaryContent:
+    def test_pdf_rejected_with_hint(self, monkeypatch):
+        """PDF 应返回明确错误并引导改用 http_download。"""
+        from tools import http_get as hg
+
+        def fake_open(self, req, timeout=None):
+            return FakeResponse(
+                b"%PDF-1.4 fake", headers={"Content-Type": "application/pdf"}
+            )
+
+        monkeypatch.setattr(hg, "make_opener", lambda: _fake_opener(fake_open))
+        r = get("http://example.com/doc.pdf")
+        assert r["ok"] is False
+        assert r["status"] == 200
+        assert r["content_type"] == "application/pdf"
+        assert "http_download" in r["hint"]
+        assert "final_url" in r
+
+    def test_image_rejected(self, monkeypatch):
+        """图片 Content-Type 同样分流。"""
+        from tools import http_get as hg
+
+        def fake_open(self, req, timeout=None):
+            return FakeResponse(
+                b"\x89PNG\r\n", headers={"Content-Type": "image/png"}
+            )
+
+        monkeypatch.setattr(hg, "make_opener", lambda: _fake_opener(fake_open))
+        r = get("http://example.com/pic.png")
+        assert r["ok"] is False
+        assert "http_download" in r["hint"]
+
+    def test_json_not_treated_as_binary(self, monkeypatch):
+        """application/json 是文本 API 响应，不应被分流。"""
+        from tools import http_get as hg
+
+        def fake_open(self, req, timeout=None):
+            return FakeResponse(
+                b'{"a": 1}',
+                headers={"Content-Type": "application/json; charset=utf-8"},
+            )
+
+        monkeypatch.setattr(hg, "make_opener", lambda: _fake_opener(fake_open))
+        r = get("http://example.com/api", format="text")
+        assert r["ok"] is True
+        assert '"a"' in r["content"]
+
+
+class TestFinalUrl:
+    def test_final_url_from_redirect(self, monkeypatch):
+        """重定向后应返回落地 URL。"""
+        from tools import http_get as hg
+
+        def fake_open(self, req, timeout=None):
+            return FakeResponse(
+                SAMPLE_HTML.encode("utf-8"), url="http://example.com/landing"
+            )
+
+        monkeypatch.setattr(hg, "make_opener", lambda: _fake_opener(fake_open))
+        r = get("http://example.com/start")
+        assert r["ok"] is True
+        assert r["final_url"] == "http://example.com/landing"
+
+    def test_final_url_fallback_to_request_url(self, monkeypatch):
+        """取不到落地 URL 时回退为原始请求 URL。"""
+        from tools import http_get as hg
+
+        def fake_open(self, req, timeout=None):
+            return FakeResponse(SAMPLE_HTML.encode("utf-8"))
+
+        monkeypatch.setattr(hg, "make_opener", lambda: _fake_opener(fake_open))
+        r = get("http://example.com/page")
+        assert r["ok"] is True
+        assert r["final_url"] == "http://example.com/page"
+
+
+class TestRetry:
+    @staticmethod
+    def _no_sleep(monkeypatch, hg):
+        """跳过退避等待，加速测试。"""
+        monkeypatch.setattr(hg, "_RETRY_BACKOFF", 0)
+
+    def test_retry_on_5xx_then_success(self, monkeypatch):
+        """首次 503 应重试并最终成功。"""
+        from tools import http_get as hg
+        self._no_sleep(monkeypatch, hg)
+        calls = {"n": 0}
+
+        def fake_open(self, req, timeout=None):
+            calls["n"] += 1
+            if calls["n"] == 1:
+                raise urllib.error.HTTPError(
+                    "http://example.com", 503, "Service Unavailable", None, None
+                )
+            return FakeResponse(SAMPLE_HTML.encode("utf-8"))
+
+        monkeypatch.setattr(hg, "make_opener", lambda: _fake_opener(fake_open))
+        r = get("http://example.com")
+        assert r["ok"] is True
+        assert calls["n"] == 2
+
+    def test_retry_exhausted_on_persistent_5xx(self, monkeypatch):
+        """持续 503 重试耗尽后返回错误，请求次数 = 1 + _MAX_RETRIES。"""
+        from tools import http_get as hg
+        self._no_sleep(monkeypatch, hg)
+        calls = {"n": 0}
+
+        def fake_open(self, req, timeout=None):
+            calls["n"] += 1
+            raise urllib.error.HTTPError(
+                "http://example.com", 503, "Service Unavailable", None, None
+            )
+
+        monkeypatch.setattr(hg, "make_opener", lambda: _fake_opener(fake_open))
+        r = get("http://example.com")
+        assert r["ok"] is False
+        assert r["status"] == 503
+        assert calls["n"] == 1 + hg._MAX_RETRIES
+
+    def test_no_retry_on_4xx(self, monkeypatch):
+        """404 属客户端错误，不应重试。"""
+        from tools import http_get as hg
+        self._no_sleep(monkeypatch, hg)
+        calls = {"n": 0}
+
+        def fake_open(self, req, timeout=None):
+            calls["n"] += 1
+            raise urllib.error.HTTPError(
+                "http://example.com", 404, "Not Found", None, None
+            )
+
+        monkeypatch.setattr(hg, "make_opener", lambda: _fake_opener(fake_open))
+        r = get("http://example.com")
+        assert r["ok"] is False
+        assert r["status"] == 404
+        assert calls["n"] == 1
+
+    def test_retry_on_connection_error(self, monkeypatch):
+        """连接超时属瞬时错误，应重试。"""
+        from tools import http_get as hg
+        self._no_sleep(monkeypatch, hg)
+        calls = {"n": 0}
+
+        def fake_open(self, req, timeout=None):
+            calls["n"] += 1
+            if calls["n"] == 1:
+                raise urllib.error.URLError("timed out")
+            return FakeResponse(SAMPLE_HTML.encode("utf-8"))
+
+        monkeypatch.setattr(hg, "make_opener", lambda: _fake_opener(fake_open))
+        r = get("http://example.com")
+        assert r["ok"] is True
+        assert calls["n"] == 2
+
+    def test_no_retry_on_ssrf_redirect_block(self, monkeypatch):
+        """SSRF 重定向拦截是安全决策，绝不能重试。"""
+        from tools import http_get as hg
+        from tools._http_utils import SsrfBlocked
+        self._no_sleep(monkeypatch, hg)
+        calls = {"n": 0}
+
+        def fake_open(self, req, timeout=None):
+            calls["n"] += 1
+            raise SsrfBlocked("重定向目标被拦截: 禁止访问内网地址: 127.0.0.1")
+
+        monkeypatch.setattr(hg, "make_opener", lambda: _fake_opener(fake_open))
+        r = get("http://example.com")
+        assert r["ok"] is False
+        assert calls["n"] == 1
+
+
+class TestPaginationCache:
+    def test_pagination_serves_from_cache_without_redownload(self, monkeypatch):
+        """翻页命中缓存时不应再次发起网络请求（整个翻页周期只下载一次）。"""
+        _clear_cache()
+        from tools import http_get as hg
+        calls = {"n": 0}
+
+        def fake_open(self, req, timeout=None):
+            calls["n"] += 1
+            return FakeResponse(SAMPLE_HTML_LONG.encode("utf-8"))
+
+        monkeypatch.setattr(hg, "make_opener", lambda: _fake_opener(fake_open))
+        r1 = get("http://example.com", format="markdown")
+        assert r1["has_more"] is True
+        next_offset = r1["next_call"]["params"]["offset"]
+
+        r2 = get("http://example.com", format="markdown", offset=next_offset)
+        assert r2["ok"] is True
+        assert r2["content"] != r1["content"]
+        assert calls["n"] == 1  # 关键断言：翻页零网络请求
+
+    def test_pagination_cache_survives_network_failure(self, monkeypatch):
+        """翻页时对端宕机/网络断开，缓存命中仍应正常返回。"""
+        _clear_cache()
+        from tools import http_get as hg
+        calls = {"n": 0}
+
+        def fake_open(self, req, timeout=None):
+            calls["n"] += 1
+            if calls["n"] > 1:
+                raise urllib.error.URLError("connection refused")
+            return FakeResponse(SAMPLE_HTML_LONG.encode("utf-8"))
+
+        monkeypatch.setattr(hg, "make_opener", lambda: _fake_opener(fake_open))
+        monkeypatch.setattr(hg, "_RETRY_BACKOFF", 0)
+        r1 = get("http://example.com", format="markdown")
+        next_offset = r1["next_call"]["params"]["offset"]
+
+        r2 = get("http://example.com", format="markdown", offset=next_offset)
+        assert r2["ok"] is True  # 网络已"断"，但缓存兜底
+        assert r2["offset"] == next_offset
+        assert len(r2["content"]) > 0
+        assert calls["n"] == 1  # 缓存命中，未触发第二次（必失败的）请求
+
+
+# 模拟 SPA 页面：大量脚本 + 几乎无文本
+SPA_HTML = (
+    '<html><head><title>SPA</title></head><body><div id="app"></div>'
+    "<script>" + "var x = 1; " * 400 + "</script></body></html>"
+)
+
+
+class TestCompression:
+    def test_gzip_body_decompressed(self, monkeypatch):
+        """Content-Encoding: gzip 的响应应自动解压。"""
+        import gzip as gz
+        from tools import http_get as hg
+
+        payload = gz.compress(SAMPLE_HTML.encode("utf-8"))
+
+        def fake_open(self, req, timeout=None):
+            return FakeResponse(payload, headers={
+                "Content-Type": "text/html; charset=utf-8",
+                "Content-Encoding": "gzip",
+            })
+
+        monkeypatch.setattr(hg, "make_opener", lambda: _fake_opener(fake_open))
+        r = get("http://example.com", format="html")
+        assert r["ok"] is True
+        assert "<h1>Hello World</h1>" in r["body"]
+
+    def test_deflate_body_decompressed(self, monkeypatch):
+        """Content-Encoding: deflate 的响应应自动解压。"""
+        import zlib
+        from tools import http_get as hg
+
+        payload = zlib.compress(SAMPLE_HTML.encode("utf-8"))
+
+        def fake_open(self, req, timeout=None):
+            return FakeResponse(payload, headers={
+                "Content-Type": "text/html; charset=utf-8",
+                "Content-Encoding": "deflate",
+            })
+
+        monkeypatch.setattr(hg, "make_opener", lambda: _fake_opener(fake_open))
+        r = get("http://example.com", format="html")
+        assert r["ok"] is True
+        assert "<h1>Hello World</h1>" in r["body"]
+
+    def test_gzip_requested_via_accept_encoding(self, monkeypatch):
+        """未自定义 headers 时应自动广告 Accept-Encoding: gzip。"""
+        from tools import http_get as hg
+        captured = {}
+
+        def fake_open(self, req, timeout=None):
+            captured["ae"] = req.headers.get("Accept-encoding")  # urllib 首字母大写
+            return FakeResponse(SAMPLE_HTML.encode("utf-8"))
+
+        monkeypatch.setattr(hg, "make_opener", lambda: _fake_opener(fake_open))
+        get("http://example.com", format="html")
+        assert captured["ae"] is not None
+        assert "gzip" in captured["ae"]
+
+
+class TestErrorHints:
+    def test_404_hint(self, monkeypatch):
+        from tools import http_get as hg
+
+        def fake_open(self, req, timeout=None):
+            raise urllib.error.HTTPError(
+                "http://example.com", 404, "Not Found", None, None
+            )
+
+        monkeypatch.setattr(hg, "make_opener", lambda: _fake_opener(fake_open))
+        r = get("http://example.com/missing")
+        assert r["ok"] is False
+        assert r["status"] == 404
+        assert "不存在" in r["hint"]
+        assert "retries" not in r  # 4xx 不重试
+
+    def test_403_hint_mentions_antibot(self, monkeypatch):
+        from tools import http_get as hg
+
+        def fake_open(self, req, timeout=None):
+            raise urllib.error.HTTPError(
+                "http://example.com", 403, "Forbidden", None, None
+            )
+
+        monkeypatch.setattr(hg, "make_opener", lambda: _fake_opener(fake_open))
+        r = get("http://example.com")
+        assert r["ok"] is False
+        assert "反爬" in r["hint"]
+
+    def test_5xx_exhausted_reports_retries(self, monkeypatch):
+        from tools import http_get as hg
+        monkeypatch.setattr(hg, "_RETRY_BACKOFF", 0)
+
+        def fake_open(self, req, timeout=None):
+            raise urllib.error.HTTPError(
+                "http://example.com", 503, "Service Unavailable", None, None
+            )
+
+        monkeypatch.setattr(hg, "make_opener", lambda: _fake_opener(fake_open))
+        r = get("http://example.com")
+        assert r["ok"] is False
+        assert r["retries"] == hg._MAX_RETRIES
+        assert "已自动重试" in r["error"]
+        assert "服务端错误" in r["hint"]
+
+    def test_timeout_hint(self, monkeypatch):
+        from tools import http_get as hg
+        monkeypatch.setattr(hg, "_RETRY_BACKOFF", 0)
+
+        def fake_open(self, req, timeout=None):
+            raise urllib.error.URLError(TimeoutError("timed out"))
+
+        monkeypatch.setattr(hg, "make_opener", lambda: _fake_opener(fake_open))
+        r = get("http://example.com", timeout=7)
+        assert r["ok"] is False
+        assert "timeout=7" in r["hint"]
+        assert r["retries"] == hg._MAX_RETRIES
+
+    def test_dns_hint(self, monkeypatch):
+        from tools import http_get as hg
+        monkeypatch.setattr(hg, "_RETRY_BACKOFF", 0)
+
+        def fake_open(self, req, timeout=None):
+            raise urllib.error.URLError(
+                socket.gaierror(-2, "Name or service not known")
+            )
+
+        monkeypatch.setattr(hg, "make_opener", lambda: _fake_opener(fake_open))
+        r = get("http://example.com")
+        assert r["ok"] is False
+        assert "域名解析失败" in r["hint"]
+
+    def test_ssrf_redirect_message_not_disguised(self, monkeypatch):
+        """SSRF 拦截不应伪装成'连接失败'。"""
+        from tools import http_get as hg
+        from tools._http_utils import SsrfBlocked
+
+        def fake_open(self, req, timeout=None):
+            raise SsrfBlocked("重定向目标被拦截: 禁止访问内网地址: 127.0.0.1")
+
+        monkeypatch.setattr(hg, "make_opener", lambda: _fake_opener(fake_open))
+        r = get("http://example.com")
+        assert r["ok"] is False
+        assert r["error"].startswith("重定向目标被拦截")
+        assert "连接失败" not in r["error"]
+
+
+class TestJsRenderedHint:
+    def test_script_content_not_leaked(self, monkeypatch):
+        """内联脚本源码不应泄漏进转换结果（markdownify strip 只去标签）。"""
+        _clear_cache()
+        from tools import http_get as hg
+        html = (
+            "<html><body><p>真正的正文内容在这里。</p>"
+            "<script>var tracker = 'x'; " * 100 + "</script></body></html>"
+        )
+
+        def fake_open(self, req, timeout=None):
+            return FakeResponse(html.encode("utf-8"))
+
+        monkeypatch.setattr(hg, "make_opener", lambda: _fake_opener(fake_open))
+        r = get("http://example.com", format="markdown")
+        assert r["ok"] is True
+        assert "真正的正文内容" in r["content"]
+        assert "tracker" not in r["content"]
+
+    def test_spa_page_gets_hint(self, monkeypatch):
+        """大量脚本 + 几乎无文本的页面应提示疑似 JS 渲染。"""
+        from tools import http_get as hg
+
+        def fake_open(self, req, timeout=None):
+            return FakeResponse(SPA_HTML.encode("utf-8"))
+
+        monkeypatch.setattr(hg, "make_opener", lambda: _fake_opener(fake_open))
+        r = get("http://example.com", format="markdown")
+        assert r["ok"] is True
+        assert "hint" in r
+        assert "JS" in r["hint"]
+
+    def test_normal_page_no_hint(self, monkeypatch):
+        """正常文本页面不应误报。"""
+        _clear_cache()
+        from tools import http_get as hg
+
+        def fake_open(self, req, timeout=None):
+            return FakeResponse(SAMPLE_HTML.encode("utf-8"))
+
+        monkeypatch.setattr(hg, "make_opener", lambda: _fake_opener(fake_open))
+        r = get("http://example.com", format="markdown")
+        assert r["ok"] is True
+        assert "hint" not in r
+
+
+class TestTimeoutClamp:
+    def test_timeout_clamped_to_600(self, monkeypatch):
+        from tools import http_get as hg
+        captured = {}
+
+        def fake_open(self, req, timeout=None):
+            captured["timeout"] = timeout
+            return FakeResponse(SAMPLE_HTML.encode("utf-8"))
+
+        monkeypatch.setattr(hg, "make_opener", lambda: _fake_opener(fake_open))
+        get("http://example.com", timeout=9999)
+        assert captured["timeout"] == 600
+
+    def test_timeout_floor_is_1(self, monkeypatch):
+        from tools import http_get as hg
+        captured = {}
+
+        def fake_open(self, req, timeout=None):
+            captured["timeout"] = timeout
+            return FakeResponse(SAMPLE_HTML.encode("utf-8"))
+
+        monkeypatch.setattr(hg, "make_opener", lambda: _fake_opener(fake_open))
+        get("http://example.com", timeout=-3)
+        assert captured["timeout"] == 1
+
+    def test_timeout_invalid_uses_default(self, monkeypatch):
+        from tools import http_get as hg
+        captured = {}
+
+        def fake_open(self, req, timeout=None):
+            captured["timeout"] = timeout
+            return FakeResponse(SAMPLE_HTML.encode("utf-8"))
+
+        monkeypatch.setattr(hg, "make_opener", lambda: _fake_opener(fake_open))
+        get("http://example.com", timeout="abc")
+        assert captured["timeout"] == 15
+
+
+class TestRetryConnectionErrors:
+    def test_retry_on_remote_disconnected(self, monkeypatch):
+        """RemoteDisconnected（非 URLError）属瞬时连接错误，应纳入重试。"""
+        import http.client
+        from tools import http_get as hg
+        monkeypatch.setattr(hg, "_RETRY_BACKOFF", 0)
+        calls = {"n": 0}
+
+        def fake_open(self, req, timeout=None):
+            calls["n"] += 1
+            if calls["n"] <= 2:
+                raise http.client.RemoteDisconnected("Remote end closed connection")
+            return FakeResponse(SAMPLE_HTML.encode("utf-8"))
+
+        monkeypatch.setattr(hg, "make_opener", lambda: _fake_opener(fake_open))
+        r = get("http://example.com")
+        assert r["ok"] is True
+        assert calls["n"] == 3
+
+    def test_connection_reset_exhausted_reports_retries(self, monkeypatch):
+        """持续连接重置：重试耗尽后报错并透传 retries。"""
+        from tools import http_get as hg
+        monkeypatch.setattr(hg, "_RETRY_BACKOFF", 0)
+
+        def fake_open(self, req, timeout=None):
+            raise ConnectionResetError(104, "Connection reset by peer")
+
+        monkeypatch.setattr(hg, "make_opener", lambda: _fake_opener(fake_open))
+        r = get("http://example.com")
+        assert r["ok"] is False
+        assert r["retries"] == hg._MAX_RETRIES
+        assert "连接中断" in r["error"]
+
+
+class TestOffsetCoercion:
+    def test_offset_string_coerced(self, monkeypatch):
+        """LLM 传字符串 offset 应被容错转换，而非抛 TypeError。"""
+        _clear_cache()
+        from tools import http_get as hg
+
+        def fake_open(self, req, timeout=None):
+            return FakeResponse(SAMPLE_HTML_LONG.encode("utf-8"))
+
+        monkeypatch.setattr(hg, "make_opener", lambda: _fake_opener(fake_open))
+        r1 = get("http://example.com", format="markdown")
+        nxt = r1["next_call"]["params"]["offset"]
+        r2 = get("http://example.com", format="markdown", offset=str(nxt))
+        assert r2["ok"] is True
+        assert r2["offset"] == nxt
+
+    def test_offset_invalid_string_returns_error(self):
+        r = get("http://example.com", offset="abc")
+        assert r["ok"] is False
+        assert "offset" in r["error"]
+
+
+class TestDecompressionSafety:
+    def test_gzip_bomb_bounded(self, monkeypatch):
+        """压缩炸弹：10MB 全同字符（gzip ~10KB），解压必须流式限长。"""
+        import gzip as gz
+        from tools import http_get as hg
+
+        payload = gz.compress(b"A" * (10 * 1024 * 1024))
+
+        def fake_open(self, req, timeout=None):
+            return FakeResponse(payload, headers={
+                "Content-Type": "text/html", "Content-Encoding": "gzip"})
+
+        monkeypatch.setattr(hg, "make_opener", lambda: _fake_opener(fake_open))
+        r = get("http://example.com", format="html")
+        assert r["ok"] is True
+        assert r["truncated"] is True
+        assert r["size"] == hg._MAX_RESPONSE_SIZE  # 解压输出被限长在 5MB
+
+    def test_truncated_gzip_returns_partial_not_garbage(self, monkeypatch):
+        """下载截断的 gzip 流：返回已解压部分内容并标记 truncated，而非压缩垃圾。"""
+        import gzip as gz
+        import os
+        from tools import http_get as hg
+
+        payload = gz.compress(os.urandom(6 * 1024 * 1024))  # 不可压缩 → >5MB
+
+        def fake_open(self, req, timeout=None):
+            return FakeResponse(payload, headers={
+                "Content-Type": "text/plain", "Content-Encoding": "gzip"})
+
+        monkeypatch.setattr(hg, "make_opener", lambda: _fake_opener(fake_open))
+        r = get("http://example.com", format="html")
+        assert r["ok"] is True
+        assert r["truncated"] is True
+        assert len(r["body"]) > 0
+
+    def test_unsupported_content_encoding_br(self, monkeypatch):
+        """服务器强制 br 编码：明确报错而非返回乱码。"""
+        from tools import http_get as hg
+
+        def fake_open(self, req, timeout=None):
+            return FakeResponse(b"whatever", headers={
+                "Content-Type": "text/html", "Content-Encoding": "br"})
+
+        monkeypatch.setattr(hg, "make_opener", lambda: _fake_opener(fake_open))
+        r = get("http://example.com")
+        assert r["ok"] is False
+        assert "br" in r["error"]
+
+
+class TestCacheCredentialsIsolation:
+    AUTH = {"Authorization": "Bearer SECRET-TOKEN"}
+
+    def test_next_call_carries_headers(self, monkeypatch):
+        """带 headers 的翻页：next_call 必须透传 headers，否则缓存指纹对不上。"""
+        _clear_cache()
+        from tools import http_get as hg
+
+        def fake_open(self, req, timeout=None):
+            return FakeResponse(SAMPLE_HTML_LONG.encode("utf-8"))
+
+        monkeypatch.setattr(hg, "make_opener", lambda: _fake_opener(fake_open))
+        r1 = get("http://example.com", format="markdown", headers=self.AUTH)
+        assert r1["has_more"] is True
+        assert r1["next_call"]["params"].get("headers") == self.AUTH
+
+    def test_authed_pagination_hits_own_cache(self, monkeypatch):
+        """同一凭据的翻页命中自己的缓存，不重复下载。"""
+        _clear_cache()
+        from tools import http_get as hg
+        calls = {"n": 0}
+
+        def fake_open(self, req, timeout=None):
+            calls["n"] += 1
+            return FakeResponse(SAMPLE_HTML_LONG.encode("utf-8"))
+
+        monkeypatch.setattr(hg, "make_opener", lambda: _fake_opener(fake_open))
+        r1 = get("http://example.com", format="markdown", headers=self.AUTH)
+        nxt = r1["next_call"]["params"]["offset"]
+        r2 = get("http://example.com", format="markdown", offset=nxt, headers=self.AUTH)
+        assert r2["ok"] is True
+        assert calls["n"] == 1
+
+    def test_anonymous_cannot_hit_credentialed_cache(self, monkeypatch):
+        """无凭据方翻页不得命中带凭据缓存（跨凭据泄露回归）。"""
+        _clear_cache()
+        from tools import http_get as hg
+        calls = {"n": 0}
+
+        def fake_open(self, req, timeout=None):
+            calls["n"] += 1
+            return FakeResponse(SAMPLE_HTML_LONG.encode("utf-8"))
+
+        monkeypatch.setattr(hg, "make_opener", lambda: _fake_opener(fake_open))
+        r1 = get("http://example.com", format="markdown", headers=self.AUTH)
+        nxt = r1["next_call"]["params"]["offset"]
+        get("http://example.com", format="markdown", offset=nxt)  # 无凭据
+        assert calls["n"] == 2  # 未命中带凭据缓存，重新下载
+
+
+class TestStripTagBlocks:
+    def test_closed_block_removed(self):
+        from tools.http_get import _strip_tag_blocks
+        out = _strip_tag_blocks("<p>1</p><script>var a=1;</script><p>2</p>", "script")
+        assert out == "<p>1</p><p>2</p>"
+
+    def test_unclosed_keeps_content(self):
+        """无闭合标签：只丢开标签、保留后续内容，不误删正文。"""
+        from tools.http_get import _strip_tag_blocks
+        assert _strip_tag_blocks("<p>1</p><script>var a=1;", "script") == "<p>1</p>var a=1;"
+
+    def test_unclosed_flood_is_linear(self):
+        """大量无闭合 <script 不得退化为 O(n·m)（ReDoS 回归）。"""
+        import time
+        from tools.http_get import _strip_tag_blocks
+        html = "<p>x</p>" + "<script " * 20000
+        start = time.monotonic()
+        _strip_tag_blocks(html, "script")
+        assert time.monotonic() - start < 1.0
+
+
+class TestReadLimitedBoundary:
+    def test_exactly_max_bytes_not_truncated(self):
+        from tools import http_get as hg
+        body, truncated = hg._read_limited(FakeResponse(b"x" * hg._MAX_RESPONSE_SIZE))
+        assert truncated is False
+        assert len(body) == hg._MAX_RESPONSE_SIZE
+
+    def test_max_bytes_plus_one_truncated(self):
+        from tools import http_get as hg
+        body, truncated = hg._read_limited(
+            FakeResponse(b"x" * (hg._MAX_RESPONSE_SIZE + 1)))
+        assert truncated is True
+
+
+class TestUserHeadersCaseInsensitive:
+    def test_lowercase_user_headers_not_overridden(self, monkeypatch):
+        """用户传小写 header 名时不应被默认 UA/Accept-Encoding 覆盖。"""
+        from tools import http_get as hg
+        captured = {}
+
+        def fake_open(self, req, timeout=None):
+            captured.update(req.headers)
+            return FakeResponse(SAMPLE_HTML.encode("utf-8"))
+
+        monkeypatch.setattr(hg, "make_opener", lambda: _fake_opener(fake_open))
+        get("http://example.com", format="html",
+            headers={"user-agent": "Mine/1.0", "accept-encoding": "br"})
+        assert captured.get("User-agent") == "Mine/1.0"
+        assert captured.get("Accept-encoding") == "br"
+
+
+class TestHttpError429:
+    def test_429_not_retried_and_hint(self, monkeypatch):
+        """429 不自动重试（对限流无效），hint 措辞与行为一致。"""
+        from tools import http_get as hg
+        monkeypatch.setattr(hg, "_RETRY_BACKOFF", 0)
+        calls = {"n": 0}
+
+        def fake_open(self, req, timeout=None):
+            calls["n"] += 1
+            raise urllib.error.HTTPError(
+                "http://example.com", 429, "Too Many Requests", None, None)
+
+        monkeypatch.setattr(hg, "make_opener", lambda: _fake_opener(fake_open))
+        r = get("http://example.com")
+        assert r["ok"] is False
+        assert calls["n"] == 1
+        assert "限流" in r["hint"]
+
+
+class TestPostBinary:
+    def test_post_pdf_rejected_with_hint(self, monkeypatch):
+        """POST 与 GET 一致：二进制响应分流报错。"""
+        from tools import http_get as hg
+
+        def fake_open(self, req, timeout=None):
+            return FakeResponse(b"%PDF-1.4", headers={"Content-Type": "application/pdf"})
+
+        monkeypatch.setattr(hg, "make_opener", lambda: _fake_opener(fake_open))
+        r = post("http://example.com/upload", data={"a": 1})
+        assert r["ok"] is False
+        assert "http_download" in r["hint"]
diff --git a/tests/test_http_utils.py b/tests/test_http_utils.py
index 6e2add5..7b451e3 100644
--- a/tests/test_http_utils.py
+++ b/tests/test_http_utils.py
@@ -2,7 +2,9 @@
 
 import socket
 
-from tools._http_utils import validate_url
+import pytest
+
+from tools._http_utils import SafeRedirectHandler, SsrfBlocked, validate_url
 
 
 class TestValidateUrl:
@@ -51,3 +53,14 @@ def test_blocks_dns_rebind_to_localhost(self):
         err = validate_url("http://localhost/")
         assert err is not None
         assert "127.0.0.1" in err["error"] or "::1" in err["error"]
+
+    def test_redirect_to_private_raises_ssrf_blocked(self):
+        """重定向到内网应抛 SsrfBlocked 专用异常（调用方按类型识别不重试）。"""
+        handler = SafeRedirectHandler()
+        with pytest.raises(SsrfBlocked):
+            handler.redirect_request(None, None, 302, "Found", {}, "http://127.0.0.1/x")
+
+    def test_ssrf_blocked_is_url_error(self):
+        """SsrfBlocked 必须是 URLError 子类，保证既有异常处理链路兼容。"""
+        import urllib.error
+        assert issubclass(SsrfBlocked, urllib.error.URLError)
diff --git a/tools/_http_utils.py b/tools/_http_utils.py
index 65004e8..01a675b 100644
--- a/tools/_http_utils.py
+++ b/tools/_http_utils.py
@@ -5,9 +5,14 @@
 
 import ipaddress
 import socket
+import urllib.error
 import urllib.request
 from urllib.parse import urlparse
 
+
+class SsrfBlocked(urllib.error.URLError):
+    """SSRF 重定向拦截专用异常——调用方按类型识别，不依赖消息文案。"""
+
 _PRIVATE_NETS = [
     ipaddress.ip_network("127.0.0.0/8"),
     ipaddress.ip_network("10.0.0.0/8"),
@@ -67,7 +72,7 @@ class SafeRedirectHandler(urllib.request.HTTPRedirectHandler):
     def redirect_request(self, req, fp, code, msg, headers, newurl):
         err = validate_url(newurl)
         if err:
-            raise urllib.error.URLError(f"重定向目标被拦截: {err['error']}")
+            raise SsrfBlocked(f"重定向目标被拦截: {err['error']}")
         return super().redirect_request(req, fp, code, msg, headers, newurl)
 
 
diff --git a/tools/_registry.py b/tools/_registry.py
index 4dab243..ad8c5fc 100644
--- a/tools/_registry.py
+++ b/tools/_registry.py
@@ -605,7 +605,7 @@ def _port_check_w(host: str = "127.0.0.1", ports: list | None = None) -> dict:
 
 HttpGetTool = make_tool(
     "http_get",
-    "【HTTP GET 唯一选择】HTTP GET 请求 + 智能内容转换。不要用 astrbot_execute_shell 跑 curl——它无 SSRF（内网 IP）防护。默认 format='markdown' 转为 LLM 友好 Markdown 并支持 offset 分页翻页；format='text' 提取纯文本正文；format='html' 返回原始 HTML（5000 字符截断，无分页，仅调试用）。extract=true 先提取正文再转换（trafilatura 去广告/导航/页脚），默认 false 全页转换。15s 超时。",
+    "【HTTP GET 唯一选择】HTTP GET 请求 + 智能内容转换。不要用 astrbot_execute_shell 跑 curl——它无 SSRF（内网 IP）防护。默认 format='markdown' 转为 LLM 友好 Markdown 并支持 offset 分页翻页；format='text' 提取纯文本正文；format='html' 返回原始 HTML（5000 字符截断，无分页，仅调试用）。extract=true 先提取正文再转换（trafilatura 去广告/导航/页脚），默认 false 全页转换。15s 超时。自动编码嗅探（GBK 等老站不乱码）、gzip/deflate 自动解压；5xx/连接错误自动指数退避重试；返回含 final_url（重定向后落地地址）与 content_type；错误附排查 hint（如 403 反爬、超时、DNS）；目标为 PDF/图片等二进制内容时返回错误并提示改用 http_download。",
     {
             "type": "object",
             "properties": {
diff --git a/tools/http_get.py b/tools/http_get.py
index 7c48b19..84fa97c 100644
--- a/tools/http_get.py
+++ b/tools/http_get.py
@@ -1,6 +1,6 @@
 """
 http_get — 纯标准库 HTTP 客户端。
-快速 GET/POST，10s 超时，返回 status + body + size。
+快速 GET/POST，默认 15s 超时（可调），返回 status + body + size。
 用于取 raw GitHub 内容、API 调用等场景。
 """
 from __future__ import annotations
@@ -9,13 +9,17 @@
 import threading
 import time
 
+import http.client
+import json
+import math
 import re
-import urllib.request
+import socket
 import urllib.error
-import json
+import urllib.request
+import zlib
 from typing import Any
 
-from ._http_utils import check_url, make_opener
+from ._http_utils import SsrfBlocked, check_url, make_opener
 
 
 _MAX_RESPONSE_SIZE = 5 * 1024 * 1024  # 5MB：超过此大小截断
@@ -24,14 +28,31 @@
 _PAGE_CACHE_SIZE = 10  # 最多缓存的页面数（LRU 淘汰）
 _PAGE_CACHE_TTL = 300  # 页面缓存有效期（秒），过期重新请求
 _DEFAULT_TIMEOUT = 15  # 默认超时秒数
+_MAX_RETRIES = 2  # GET 失败重试次数（仅 5xx / 连接错误；POST 非幂等不重试）
+_RETRY_BACKOFF = 0.5  # 重试退避基数（秒），按 2^attempt 指数增长
+_TOTAL_BUDGET_CAP = 180  # 重试总耗时预算上限（秒），防大 timeout × 重试放大阻塞
 
-# ── 翻页缓存：key=(url, format, extract) → 完整转换结果 ──
+
+# ── 翻页缓存：key=(url, format, extract, headers指纹) → 完整转换结果 ──
 _page_cache: OrderedDict = OrderedDict()
 _page_cache_lock = threading.Lock()
 
+# headers 无法规范化时的哨兵：跳过缓存读写（绝不退化到无头共享 key，防跨凭据泄露）
+_NO_CACHE = object()
+
 
-def _cache_key(url: str, format: str, extract: bool) -> tuple:
-    return (url, format, extract)
+def _headers_fingerprint(headers: dict | None):
+    """请求头规范化指纹（小写键排序）。None=无自定义头；_NO_CACHE=不可缓存。"""
+    if not headers:
+        return None
+    try:
+        return tuple(sorted((str(k).lower(), str(v)) for k, v in headers.items()))
+    except Exception:
+        return _NO_CACHE
+
+
+def _cache_key(url: str, format: str, extract: bool, headers_fp=None) -> tuple:
+    return (url, format, extract, headers_fp)
 
 
 def _get_cached(key: tuple) -> dict | None:
@@ -59,8 +80,105 @@ def _set_cache(key: tuple, entry: dict) -> None:
         _page_cache[key] = entry
 
 
-def _read_limited(resp, max_bytes: int = _MAX_RESPONSE_SIZE) -> str:
-    """分块读取响应体，超过 max_bytes 时截断。"""
+_BINARY_CT_EXACT = frozenset({
+    "application/pdf",
+    "application/octet-stream",
+    "application/zip",
+    "application/gzip",
+    "application/x-tar",
+    "application/x-bzip2",
+    "application/x-xz",
+    "application/x-7z-compressed",
+    "application/x-rar-compressed",
+    "application/msword",
+    "application/wasm",
+})
+_BINARY_CT_PREFIXES = ("image/", "audio/", "video/", "font/", "application/vnd.")
+
+
+def _resp_content_type(resp) -> str:
+    """取响应 Content-Type 主类型（小写、去参数），取不到返回空串。"""
+    headers = getattr(resp, "headers", None)
+    if headers is None:
+        return ""
+    ct = headers.get("Content-Type", "") or ""
+    return ct.split(";")[0].strip().lower()
+
+
+def _resp_final_url(resp, url: str) -> str:
+    """取重定向后的落地 URL，取不到回退为原始 url。"""
+    geturl = getattr(resp, "geturl", None)
+    if callable(geturl):
+        try:
+            return geturl() or url
+        except Exception:
+            pass
+    return url
+
+
+def _is_binary_content_type(content_type: str) -> bool:
+    """判断 Content-Type 是否为不可文本化的二进制内容。"""
+    if not content_type:
+        return False
+    if content_type in _BINARY_CT_EXACT:
+        return True
+    return any(content_type.startswith(p) for p in _BINARY_CT_PREFIXES)
+
+
+def _detect_charset(resp, raw: bytes) -> str:
+    """编码嗅探：Content-Type charset → charset_normalizer/chardet（可选依赖）→ utf-8。"""
+    headers = getattr(resp, "headers", None)
+    if headers is not None:
+        ct = headers.get("Content-Type", "") or ""
+        m = re.search(r'charset=["\']?([\w.\-]+)', ct, re.IGNORECASE)
+        if m:
+            return m.group(1)
+    try:
+        from charset_normalizer import from_bytes
+        best = from_bytes(raw).best()
+        if best is not None:
+            return best.encoding
+    except Exception:
+        pass
+    try:
+        import chardet
+        result = chardet.detect(raw)
+        if result and result.get("encoding"):
+            return result["encoding"]
+    except Exception:
+        pass
+    return "utf-8"
+
+
+class _BodyReadError(Exception):
+    """响应体读取/解压失败，消息可直接作为 error 返回给调用方。"""
+
+
+def _decompress_limited(raw: bytes, content_encoding: str, max_bytes: int) -> tuple:
+    """流式解压并限长（内存峰值有界，防压缩炸弹）。返回 (data, hit_limit)。
+
+    下载截断的压缩流不抛错——返回已解压的部分内容（以 hit_limit 标记）；
+    数据损坏或编码声明不实时抛 _BodyReadError。
+    """
+    if content_encoding in ("gzip", "x-gzip"):
+        wbits_list = (16 + zlib.MAX_WBITS,)
+    else:  # deflate：先按 zlib 头解析，失败回退 raw deflate
+        wbits_list = (zlib.MAX_WBITS, -zlib.MAX_WBITS)
+    last_err = None
+    for wbits in wbits_list:
+        d = zlib.decompressobj(wbits)
+        try:
+            out = d.decompress(raw, max_bytes + 1)
+        except zlib.error as e:
+            last_err = e
+            continue
+        hit_limit = len(out) > max_bytes or bool(d.unconsumed_tail) or not d.eof
+        return out[:max_bytes], hit_limit
+    raise _BodyReadError(f"{content_encoding} 解压失败（数据损坏或编码声明不实）: {last_err}")
+
+
+def _read_limited(resp, max_bytes: int = _MAX_RESPONSE_SIZE) -> tuple:
+    """分块读取响应体（上限 max_bytes），按嗅探到的编码解码。返回 (body, truncated)。"""
     chunks = []
     total = 0
     while True:
@@ -71,11 +189,32 @@ def _read_limited(resp, max_bytes: int = _MAX_RESPONSE_SIZE) -> str:
         chunks.append(chunk)
         if total >= max_bytes:
             break
-    body = b"".join(chunks).decode("utf-8", errors="replace")
-    return body, total >= max_bytes
+    # 多读 1 字节确认是否真截断（避免恰好 max_bytes 时误报）
+    truncated = total >= max_bytes and bool(resp.read(1))
+    raw = b"".join(chunks)
+
+    # 解压：Accept-Encoding 协商或服务器强制压缩的结果（流式限长，防压缩炸弹）
+    headers = getattr(resp, "headers", None)
+    content_encoding = ""
+    if headers is not None:
+        content_encoding = (headers.get("Content-Encoding", "") or "").strip().lower()
+    if content_encoding in ("gzip", "x-gzip", "deflate"):
+        raw, hit_limit = _decompress_limited(raw, content_encoding, max_bytes)
+        truncated = truncated or hit_limit
+    elif content_encoding and content_encoding != "identity":
+        raise _BodyReadError(
+            f"服务器返回了不支持的压缩编码 ({content_encoding})，本工具仅支持 gzip/deflate"
+        )
+
+    charset = _detect_charset(resp, raw[:65536])  # 嗅探前 64KB 足够
+    try:
+        body = raw.decode(charset, errors="replace")
+    except (LookupError, ValueError):
+        body = raw.decode("utf-8", errors="replace")
+    return body, truncated
 
 
-def _build_response(resp) -> dict:
+def _build_response(resp, url: str = "") -> dict:
     body, was_truncated = _read_limited(resp)
     return {
         "ok": True,
@@ -83,9 +222,108 @@ def _build_response(resp) -> dict:
         "size": len(body),
         "body": body,
         "truncated": was_truncated,
+        "final_url": _resp_final_url(resp, url),
+        "content_type": _resp_content_type(resp),
     }
 
 
+def _open_with_retry(req, timeout: int, max_retries: int = _MAX_RETRIES):
+    """带指数退避的请求执行。
+
+    - 重试对象：5xx、连接层错误（URLError 及 RemoteDisconnected/ConnectionReset 等 OSError/HTTPException）
+    - 不重试：4xx（客户端错误）、SSRF 拦截（安全决策，按异常类型识别）
+    - 总耗时预算 min(timeout×尝试数, max(timeout, _TOTAL_BUDGET_CAP))，防大 timeout × 重试放大
+    - 抛出时给异常挂上 _retries 属性（已重试次数），供错误消息透传
+    """
+    budget = min(timeout * (max_retries + 1), max(timeout, _TOTAL_BUDGET_CAP))
+    start = time.monotonic()
+    for attempt in range(max_retries + 1):
+        remaining = budget - (time.monotonic() - start)
+        if remaining <= 0:
+            err = urllib.error.URLError(TimeoutError("重试总耗时预算耗尽"))
+            err._retries = attempt
+            raise err
+        try:
+            return make_opener().open(req, timeout=min(timeout, max(1, math.ceil(remaining))))
+        except urllib.error.HTTPError as e:
+            if e.code < 500 or attempt >= max_retries:
+                e._retries = attempt
+                raise
+            try:
+                e.close()  # 释放失败响应占用的套接字资源
+            except Exception:
+                pass
+        except SsrfBlocked:
+            raise  # SSRF 安全拦截：绝不重试
+        except urllib.error.URLError as e:
+            if attempt >= max_retries:
+                e._retries = attempt
+                raise
+        except (http.client.HTTPException, OSError) as e:
+            # RemoteDisconnected/ConnectionResetError 等非 URLError 的瞬时连接错误
+            if attempt >= max_retries:
+                e._retries = attempt
+                raise
+        time.sleep(_RETRY_BACKOFF * (2 ** attempt))
+
+
+_STATUS_HINTS = {
+    400: "请求格式有误——检查 URL 是否完整",
+    401: "需要认证——如需登录态，请在 headers 中携带 Authorization/Cookie",
+    403: "访问被拒——可能是反爬/WAF 拦截（本工具无浏览器指纹），可换地址、稍后重试，或寻找官方 API",
+    404: "页面不存在——检查 URL 拼写，链接可能已失效",
+    405: "方法不允许——该地址可能只接受 POST（http_post）等方法",
+    429: "触发限流——自动重试对限流无效（未执行），请等待一段时间后再手动重试",
+}
+
+
+def _http_error_dict(e, retried: int = 0) -> dict:
+    """HTTP 错误结构化：状态码 + 可操作 hint + 重试次数。"""
+    body = ""
+    try:
+        body = e.read(4096).decode("utf-8", errors="replace")[:500]
+    except Exception:
+        pass
+    error = f"HTTP {e.code}: {e.reason}"
+    if retried:
+        error += f"（已自动重试 {retried} 次）"
+    if e.code >= 500:
+        hint = "服务端错误——自动重试后仍失败，可稍后再试"
+    else:
+        hint = _STATUS_HINTS.get(e.code, "")
+    result = {"ok": False, "error": error, "status": e.code, "body": body}
+    if retried:
+        result["retries"] = retried
+    if hint:
+        result["hint"] = hint
+    return result
+
+
+def _url_error_dict(e, timeout: int, retried: int = 0) -> dict:
+    """连接层错误结构化：区分 DNS/超时/拒连，附可操作 hint。"""
+    if isinstance(e, SsrfBlocked):
+        # SSRF 安全拦截：原样透出，不伪装成网络故障
+        return {"ok": False, "error": str(getattr(e, "reason", e))}
+    reason = getattr(e, "reason", e)
+    reason_s = str(reason)
+    error = f"连接失败: {reason_s}"
+    if retried:
+        error += f"（已自动重试 {retried} 次）"
+    hint = ""
+    if isinstance(reason, socket.gaierror) or "Name or service not known" in reason_s or "Temporary failure in name resolution" in reason_s:
+        hint = "域名解析失败——检查 URL 拼写，或本机 DNS/网络是否正常"
+    elif isinstance(reason, (TimeoutError, socket.timeout)) or "timed out" in reason_s.lower():
+        hint = f"连接超时（当前 timeout={timeout}s）——可调大 timeout 后重试"
+    elif "refused" in reason_s.lower():
+        hint = "连接被拒——目标服务可能未启动或端口不通"
+    result = {"ok": False, "error": error}
+    if retried:
+        result["retries"] = retried
+    if hint:
+        result["hint"] = hint
+    return result
+
+
 def _extract_metadata(html: str) -> dict:
     """从 HTML 中提取 title 和 meta description。"""
     title = ""
@@ -109,6 +347,45 @@ def _extract_metadata(html: str) -> dict:
     return {"title": title, "description": description}
 
 
+def _strip_tag_blocks(html: str, tag: str) -> str:
+    """线性时间剔除 <tag>...</tag> 块（含内容）。
+
+    替代正则剔除：正则 <tag[\\s\\S]*?</tag> 在大量无闭合标签时退化为 O(n·m)（DoS 面）。
+    未闭合的开标签只去掉标签本身并保留后续内容，避免误删正文。
+    """
+    lower = html.lower()
+    open_pat = "<" + tag
+    close_pat = "</" + tag
+    out = []
+    i = 0
+    n = len(html)
+    while i < n:
+        j = lower.find(open_pat, i)
+        if j == -1:
+            out.append(html[i:])
+            break
+        after = j + len(open_pat)
+        # 确认是标签起始（<scriptx 之类的误命中跳过）
+        if after < n and lower[after] not in " \t\r\n>/":
+            out.append(html[i:after])
+            i = after
+            continue
+        gt = lower.find(">", after)
+        if gt == -1:
+            out.append(html[i:j])  # 开标签未闭合：丢弃标签残余，收尾
+            break
+        k = lower.find(close_pat, gt)
+        if k == -1:
+            # 全文已无闭合标签：只丢开标签，保留其余内容（防误删正文），线性收尾
+            out.append(html[i:j])
+            out.append(html[gt + 1:])
+            break
+        gt2 = lower.find(">", k + len(close_pat))
+        out.append(html[i:j])
+        i = (gt2 + 1) if gt2 != -1 else n
+    return "".join(out)
+
+
 def _convert_html(html: str, format: str, extract: bool) -> tuple[str, str]:
     """将 HTML 转换为 markdown 或 text，返回 (内容, 实际使用的转换器)。
 
@@ -121,6 +398,9 @@ def _markdown_convert(h):
         """markdownify 转换 + format=text 时去标记，失败返回 None。"""
         try:
             from markdownify import markdownify as md
+            # 先剔除 script/style 整块（含内容）——markdownify 的 strip 只去标签不去文本
+            h = _strip_tag_blocks(h, "script")
+            h = _strip_tag_blocks(h, "style")
             text = md(h, heading_style="ATX", strip=["script", "style"])
             if format == "text":
                 text = re.sub(r"^#{1,6}\s+", "", text, flags=re.MULTILINE)
@@ -170,7 +450,8 @@ def _bs4_plain(h):
     return _bs4_plain(html), "bs4"
 
 
-def _paginate(entry: dict, offset: int, url: str, format: str, extract: bool) -> dict:
+def _paginate(entry: dict, offset: int, url: str, format: str, extract: bool,
+              headers: dict | None = None) -> dict:
     """从缓存的完整内容中切出一页，附 has_more / next_call / options。"""
     content = entry["content"]
     total = len(content)
@@ -181,24 +462,26 @@ def _paginate(entry: dict, offset: int, url: str, format: str, extract: bool) ->
     options = []
     if has_more:
         next_offset = offset + len(page)
-        next_call = {
-            "tool": "http_get",
-            "params": {
-                "url": url,
-                "format": format,
-                "extract": extract,
-                "offset": next_offset,
-            },
+        params = {
+            "url": url,
+            "format": format,
+            "extract": extract,
+            "offset": next_offset,
         }
+        if headers:
+            params["headers"] = headers  # 翻页透传，保证缓存 key 的 headers 指纹一致
+        next_call = {"tool": "http_get", "params": params}
         options = [
             f"继续阅读下一页 (offset={next_offset})",
             "换个更精确的 URL 或减小范围",
         ]
 
-    return {
+    result = {
         "ok": True,
         "status": entry["status"],
         "url": url,
+        "final_url": entry.get("final_url", url),
+        "content_type": entry.get("content_type", ""),
         "title": entry["title"],
         "description": entry["description"],
         "content": page,
@@ -214,11 +497,18 @@ def _paginate(entry: dict, offset: int, url: str, format: str, extract: bool) ->
         "truncation_reason": f"共 {total} 字符，当前展示 offset={offset}~{offset + len(page)}" if has_more else "",
         "size": entry["size"],
     }
+    if entry.get("hint"):
+        result["hint"] = entry["hint"]
+    return result
 
 
 def _add_ua(req, headers: dict | None):
-    if not headers or "User-Agent" not in headers:
+    lowered = {str(k).lower() for k in headers} if headers else set()
+    if "user-agent" not in lowered:
         req.add_header("User-Agent", "IrmiaDevKit/2.3")
+    if "accept-encoding" not in lowered:
+        # 只广告内置可解压的编码；服务器强制压缩时也能正确处理
+        req.add_header("Accept-Encoding", "gzip, deflate, identity")
 
 
 def get(
@@ -240,10 +530,15 @@ def get(
         offset: 分页偏移量（字符数），0=从头读取。首次调用不传，后续通过 next_call 透传
 
     Returns:
-        format="html" 时返回 {"ok", "status", "body", "truncated", "size", "converter"}
-        format≠"html" 时返回 {"ok", "status", "url", "title", "description",
-                         "content", "content_length", "format", "extracted", "converter",
-                         "offset", "has_more", "next_call", "options", "truncated", "size"}
+        format="html" 时返回 {"ok", "status", "body", "truncated", "size", "converter",
+                         "final_url", "content_type"}
+        format≠"html" 时返回 {"ok", "status", "url", "final_url", "content_type",
+                         "title", "description", "content", "content_length", "format",
+                         "extracted", "converter", "offset", "has_more", "next_call",
+                         "options", "truncated", "size"}
+        目标为 PDF/图片等二进制内容时返回 {"ok": False, "error", "status",
+                         "content_type", "final_url", "hint"}，提示改用 http_download
+        5xx/连接错误自动指数退避重试（最多 _MAX_RETRIES 次）
     """
     err = check_url(url)
     if err:
@@ -254,14 +549,48 @@ def get(
     if format not in valid_formats:
         return {"ok": False, "error": f"format 无效: {format}，可选 {valid_formats}"}
 
+    try:
+        offset = int(offset)
+    except (TypeError, ValueError):
+        return {"ok": False, "error": f"offset 必须为整数: {offset!r}"}
     if offset < 0:
         return {"ok": False, "error": f"offset 不能为负数: {offset}"}
 
+    try:
+        timeout = max(1, min(int(timeout), 600))
+    except (TypeError, ValueError):
+        timeout = _DEFAULT_TIMEOUT
+
+    # markdown/text 翻页：先查翻页缓存，命中直接切片返回——不重复下载，
+    # 对端故障/限流时缓存内容依然可用。缓存 key 含 headers 指纹，防跨凭据串号/泄露
+    headers_fp = _headers_fingerprint(headers)
+    cacheable = headers_fp is not _NO_CACHE
+    key = None
+    if format in ("markdown", "text") and cacheable:
+        key = _cache_key(url, format, extract, headers_fp)
+        if offset > 0:
+            cached = _get_cached(key)
+            if cached is not None and offset < len(cached["content"]):
+                return _paginate(cached, offset, url, format, extract, headers)
+            # 缓存未命中、已过期或 offset 越界：回退为首次请求
+            offset = 0
+
     try:
         req = urllib.request.Request(url, headers=headers or {})
         _add_ua(req, headers)
-        with make_opener().open(req, timeout=timeout) as resp:
-            raw = _build_response(resp)
+        with _open_with_retry(req, timeout) as resp:
+            content_type = _resp_content_type(resp)
+            if _is_binary_content_type(content_type):
+                return {
+                    "ok": False,
+                    "error": f"目标是二进制内容 ({content_type})，无法作为文本读取",
+                    "status": resp.status,
+                    "content_type": content_type,
+                    "final_url": _resp_final_url(resp, url),
+                    "hint": "如需保存该文件，请改用 http_download 工具",
+                }
+
+            raw = _build_response(resp, url)
             if not raw["ok"]:
                 return raw
 
@@ -275,39 +604,47 @@ def get(
                     raw["hint"] = "HTML 已截断且无分页；改用 format='markdown' 或 'text' 可分页读取全文"
                 return raw
 
-            # format ∈ {"markdown", "text"}
-            key = _cache_key(url, format, extract)
-
-            # offset > 0：尝试从缓存翻页
-            if offset > 0:
-                cached = _get_cached(key)
-                if cached is not None and offset < len(cached["content"]):
-                    return _paginate(cached, offset, url, format, extract)
-                # 缓存未命中、已过期或 offset 越界：从头下载
-                offset = 0
-
-            # 首次请求：下载 + 转换 + 缓存
+            # format ∈ {"markdown", "text"}：首次请求 = 下载 + 转换 + 缓存
             meta = _extract_metadata(raw["body"])
             content, converter = _convert_html(raw["body"], format, extract)
+            # SPA 检测：原始 HTML 很大且含脚本，但转换后几乎无文本 → 疑似 JS 渲染
+            hint = ""
+            if (
+                len(content) < 50
+                and len(raw["body"]) > 2000
+                and re.search(r"<script[\s>]", raw["body"], re.IGNORECASE)
+            ):
+                hint = (
+                    "页面几乎无文本内容但包含脚本，疑似 JS 动态渲染（SPA）——"
+                    "本工具不执行 JS；建议寻找该站的 API/RSS/打印版，或确认 URL 是否正确"
+                )
             entry = {
                 "status": raw["status"],
                 "size": raw["size"],
+                "final_url": raw["final_url"],
+                "content_type": raw["content_type"],
                 "title": meta["title"],
                 "description": meta["description"],
                 "content": content,
                 "converter": converter,
+                "hint": hint,
             }
-            _set_cache(key, entry)
-            return _paginate(entry, offset, url, format, extract)
+            if cacheable:
+                _set_cache(key, entry)
+            return _paginate(entry, offset, url, format, extract, headers)
     except urllib.error.HTTPError as e:
-        body = ""
-        try:
-            body = e.read().decode("utf-8", errors="replace")[:500]
-        except Exception:
-            pass
-        return {"ok": False, "error": f"HTTP {e.code}: {e.reason}", "status": e.code, "body": body}
+        return _http_error_dict(e, getattr(e, "_retries", 0))
     except urllib.error.URLError as e:
-        return {"ok": False, "error": f"连接失败: {e.reason}"}
+        return _url_error_dict(e, timeout, getattr(e, "_retries", 0))
+    except _BodyReadError as e:
+        return {"ok": False, "error": str(e), "hint": "可改用 http_download 下载原始内容"}
+    except (http.client.HTTPException, OSError) as e:
+        result = {"ok": False, "error": f"连接中断: {e}"}
+        retried = getattr(e, "_retries", 0)
+        if retried:
+            result["retries"] = retried
+            result["error"] += f"（已自动重试 {retried} 次）"
+        return result
     except Exception as e:
         return {"ok": False, "error": str(e)}
 
@@ -315,7 +652,10 @@ def get(
 def post(
     url: str, data: Any = None, headers: dict | None = None, timeout: int = 10
 ) -> dict:
-    """HTTP POST 请求。data 可以是 dict（自动 JSON）或 str。"""
+    """HTTP POST 请求。data 可以是 dict（自动 JSON）或 str。
+
+    注意：POST 非幂等，不做自动重试，避免重复提交。
+    """
     err = check_url(url)
     if err:
         return err
@@ -323,6 +663,11 @@ def post(
     if data is None:
         return {"ok": False, "error": "POST 请求必须提供 data 参数"}
 
+    try:
+        timeout = max(1, min(int(timeout), 600))
+    except (TypeError, ValueError):
+        timeout = 10
+
     try:
         if isinstance(data, dict):
             data = json.dumps(data, ensure_ascii=False).encode("utf-8")
@@ -336,15 +681,24 @@ def post(
         req = urllib.request.Request(url, data=data, headers=headers or {})
         _add_ua(req, headers)
         with make_opener().open(req, timeout=timeout) as resp:
-            return _build_response(resp)
+            content_type = _resp_content_type(resp)
+            if _is_binary_content_type(content_type):
+                return {
+                    "ok": False,
+                    "error": f"目标是二进制内容 ({content_type})，无法作为文本读取",
+                    "status": resp.status,
+                    "content_type": content_type,
+                    "final_url": _resp_final_url(resp, url),
+                    "hint": "如需保存该文件，请改用 http_download 工具",
+                }
+            return _build_response(resp, url)
     except urllib.error.HTTPError as e:
-        body = ""
-        try:
-            body = e.read().decode("utf-8", errors="replace")[:500]
-        except Exception:
-            pass
-        return {"ok": False, "error": f"HTTP {e.code}: {e.reason}", "status": e.code, "body": body}
+        return _http_error_dict(e)
     except urllib.error.URLError as e:
-        return {"ok": False, "error": f"连接失败: {e.reason}"}
+        return _url_error_dict(e, timeout)
+    except _BodyReadError as e:
+        return {"ok": False, "error": str(e), "hint": "可改用 http_download 下载原始内容"}
+    except (http.client.HTTPException, OSError) as e:
+        return {"ok": False, "error": f"连接中断: {e}"}
     except Exception as e:
         return {"ok": False, "error": str(e)}