mcai-knowledge 0.2.0__py3-none-any.whl

mcai/manifest.py

@@ -0,0 +1,171 @@
+"""对外可发现性清单：让别的 AI / Agent 能自动找到并接入。
+
+生成三个机器可读文件：
+- /.well-known/mcp.json   MCP 服务器清单（传输方式、工具、示例）
+- /.well-known/agent.json Agent Card（能力、技能、入口）
+- /openapi.json           HTTP API 的 OpenAPI 3.1 描述
+"""
+from __future__ import annotations
+
+from .extract import KnowledgeBase
+
+
+def _base(project: dict) -> str:
+    return project["site_url"].rstrip("/")
+
+
+def mcp_manifest(kb: KnowledgeBase, project: dict) -> dict:
+    from .mcp_server import PROTOCOL_VERSION, SERVER_INFO, TOOLS
+
+    base = _base(project)
+    return {
+        "name": SERVER_INFO["name"],
+        "displayName": f"{project['brand']}学说知识库",
+        "description": (
+            f"可被其他 Agent 调用的{project['brand']}学说知识库："
+            f"{kb.stats['concepts']} 个术语定义、{kb.stats['faqs']} 组问答、"
+            f"{kb.stats['relations']} 条概念关系，全部带原文出处。"
+        ),
+        "version": SERVER_INFO["version"],
+        "protocolVersion": PROTOCOL_VERSION,
+        "transport": {"type": "stdio", "command": "python", "args": ["run.py", "mcp"]},
+        "capabilities": {"tools": True, "resources": True, "prompts": False},
+        "tools": [
+            {
+                "name": t["name"],
+                "description": t["description"],
+                "inputSchema": t["inputSchema"],
+            }
+            for t in TOOLS
+        ],
+        "http": {
+            "base": f"{base}/api/v1",
+            "endpoints": ["health", "catalog", "search", "concept/<slug>", "answer", "answer/batch",
+                           "related"],
+            "localOnly": ["stats", "gaps"],
+            "auth": "none (local) / Bearer token (public)",
+        },
+        "examples": [
+            {"tool": "mcai_answer", "arguments": {"question": "什么是元意识？"}},
+            {"tool": "mcai_search", "arguments": {"query": "序生", "limit": 5}},
+            {"tool": "mcai_related", "arguments": {"term": "元意识", "depth": 1}},
+        ],
+        "license": project.get("license", ""),
+        "publisher": project.get("org", ""),
+    }
+
+
+def agent_card(kb: KnowledgeBase, project: dict) -> dict:
+    base = _base(project)
+    return {
+        "name": f"{project['brand']}知识 Agent",
+        "description": (
+            f"回答关于{project['brand']}学说的问题，提供术语定义、概念关系与原文引证；"
+            "不臆造理论，资料未涉及时会明确说明。"
+        ),
+        "url": base,
+        "version": project.get("version", "0.1.0"),
+        "provider": {"organization": project.get("org", ""), "url": base},
+        "capabilities": {"streaming": False, "pushNotifications": False, "stateTransitionHistory": False},
+        "defaultInputModes": ["text/plain"],
+        "defaultOutputModes": ["application/json", "text/markdown"],
+        "skills": [
+            {
+                "id": "mcai_answer",
+                "name": "学说问答",
+                "description": "基于术语表与文献引证回答问题，返回定义、出处与相关概念。",
+                "examples": ["什么是元意识？", "序生智能体与AI涌现是什么关系？"],
+            },
+            {
+                "id": "mcai_search",
+                "name": "术语检索",
+                "description": "按中文、英文或别名检索术语。",
+                "examples": ["搜索 元知", "search meta-consciousness"],
+            },
+            {
+                "id": "mcai_related",
+                "name": "概念关系",
+                "description": "返回概念的关系子图，用于解释结构。",
+                "examples": ["元意识和元态能量是什么关系？"],
+            },
+        ],
+        "endpoints": {
+            "mcp": f"{base}/.well-known/mcp.json",
+            "http": f"{base}/api/v1",
+            "openapi": f"{base}/openapi.json",
+            "llms": f"{base}/llms.txt",
+        },
+    }
+
+
+def openapi(kb: KnowledgeBase, project: dict) -> dict:
+    base = _base(project)
+
+    def ok(schema: dict) -> dict:
+        return {"200": {"description": "OK", "content": {"application/json": {"schema": schema}}} }
+
+    return {
+        "openapi": "3.1.0",
+        "info": {
+            "title": f"{project['brand']}知识库 API",
+            "version": project.get("version", "0.1.0"),
+            "description": f"术语、问答与概念关系查询。共 {kb.stats['concepts']} 个术语。",
+        },
+        "servers": [{"url": f"{base}/api/v1"}],
+        "paths": {
+            "/health": {"get": {"summary": "健康检查", "responses": ok({"type": "object"})}},
+            "/catalog": {
+                "get": {
+                    "summary": "术语目录",
+                    "parameters": [{"name": "category", "in": "query", "schema": {"type": "string"}}],
+                    "responses": ok({"type": "object"}),
+                }
+            },
+            "/search": {
+                "get": {
+                    "summary": "检索术语",
+                    "parameters": [
+                        {"name": "q", "in": "query", "required": True, "schema": {"type": "string"}},
+                        {"name": "limit", "in": "query", "schema": {"type": "integer", "default": 8}},
+                    ],
+                    "responses": ok({"type": "object"}),
+                }
+            },
+            "/concept/{slug}": {
+                "get": {
+                    "summary": "获取词条",
+                    "parameters": [{"name": "slug", "in": "path", "required": True, "schema": {"type": "string"}}],
+                    "responses": ok({"type": "object"}),
+                }
+            },
+            "/answer": {
+                "get": {
+                    "summary": "问答（GET）",
+                    "parameters": [{"name": "q", "in": "query", "required": True, "schema": {"type": "string"}}],
+                    "responses": ok({"type": "object"}),
+                },
+                "post": {
+                    "summary": "问答（POST）",
+                    "requestBody": {
+                        "content": {"application/json": {"schema": {
+                            "type": "object", "properties": {"question": {"type": "string"}},
+                            "required": ["question"],
+                        }}}
+                    },
+                    "responses": ok({"type": "object"}),
+                },
+            },
+            "/related": {
+                "get": {
+                    "summary": "关系子图",
+                    "parameters": [
+                        {"name": "term", "in": "query", "required": True, "schema": {"type": "string"}},
+                        {"name": "depth", "in": "query", "schema": {"type": "integer", "enum": [1, 2]}},
+                    ],
+                    "responses": ok({"type": "object"}),
+                }
+            },
+            "/stats": {"get": {"summary": "调用统计", "responses": ok({"type": "object"})}},
+            "/gaps": {"get": {"summary": "未命中的问题（用于补词）", "responses": ok({"type": "object"})}},
+        },
+    }

mcai/mcp_server.py

@@ -0,0 +1,280 @@
+"""MCP（Model Context Protocol）服务器：stdio + JSON-RPC 2.0。
+
+让 Claude Desktop / Cursor / 其他 Agent 把元意识知识库当作工具与资源直接调用。
+启动：python run.py mcp
+"""
+from __future__ import annotations
+
+import json
+import sys
+from pathlib import Path
+
+from . import knowledge
+
+PROTOCOL_VERSION = "2024-11-05"
+SERVER_INFO = {"name": "mcai-knowledge", "version": "0.2.0"}
+
+TOOLS = [
+    {
+        "name": "mcai_answer",
+        "description": (
+            "回答关于元意识学说的问题。返回权威定义、原文引证与相关概念。"
+            "适合回答“什么是元意识”“序生智能体与AI涌现的关系”等问题。"
+        ),
+        "inputSchema": {
+            "type": "object",
+            "properties": {
+                "question": {"type": "string", "description": "用户问题，中英文均可"},
+            },
+            "required": ["question"],
+        },
+    },
+    {
+        "name": "mcai_concept",
+        "description": "按术语名、别名或 slug 获取单个概念的完整词条（定义、别名、出处、引证、关系）。",
+        "inputSchema": {
+            "type": "object",
+            "properties": {
+                "term": {"type": "string", "description": "术语、别名或 slug，如 元意识 / MCAI / meta-consciousness"},
+            },
+            "required": ["term"],
+        },
+    },
+    {
+        "name": "mcai_search",
+        "description": "在术语库中检索概念，支持中文关键词、英文词与别名，可按体系过滤。",
+        "inputSchema": {
+            "type": "object",
+            "properties": {
+                "query": {"type": "string"},
+                "limit": {"type": "integer", "default": 8, "minimum": 1, "maximum": 30},
+                "category": {
+                    "type": "string",
+                    "description": "可选：元意识体系 / 本体论模型 / 序生体系 / 元子社会",
+                },
+            },
+            "required": ["query"],
+        },
+    },
+    {
+        "name": "mcai_related",
+        "description": "获取概念的关系子图（含衍生关系），用于解释概念之间的因果与结构。",
+        "inputSchema": {
+            "type": "object",
+            "properties": {
+                "term": {"type": "string"},
+                "depth": {"type": "integer", "default": 1, "minimum": 1, "maximum": 2},
+            },
+            "required": ["term"],
+        },
+    },
+    {
+        "name": "mcai_list",
+        "description": "列出全部术语（可按体系过滤），用于了解知识库覆盖范围。",
+        "inputSchema": {
+            "type": "object",
+            "properties": {
+                "category": {"type": "string"},
+            },
+        },
+    },
+]
+
+
+PROMPTS = [
+    {
+        "name": "explain_concept",
+        "description": "用元意识学说的定义解释一个术语，要求区分同名概念。",
+        "arguments": [{"name": "term", "description": "术语名", "required": True}],
+    },
+    {
+        "name": "analyze_phenomenon",
+        "description": "用元意识学说的框架分析一个现象，先取定义再推理。",
+        "arguments": [{"name": "phenomenon", "description": "现象或问题", "required": True}],
+    },
+    {
+        "name": "compare_terms",
+        "description": "比较两个术语，先取两者定义与关系再作答。",
+        "arguments": [
+            {"name": "a", "description": "术语 A", "required": True},
+            {"name": "b", "description": "术语 B", "required": True},
+        ],
+    },
+]
+
+def _text(payload: dict | list | str) -> dict:
+    body = payload if isinstance(payload, str) else json.dumps(payload, ensure_ascii=False, indent=2)
+    return {"content": [{"type": "text", "text": body}], "isError": False}
+
+
+def _error(message: str) -> dict:
+    return {"content": [{"type": "text", "text": message}], "isError": True}
+
+
+def call_tool(kb: knowledge.Knowledge, name: str, args: dict) -> dict:
+    if name == "mcai_answer":
+        return _text(kb.answer(str(args.get("question", ""))))
+    if name == "mcai_concept":
+        concept = kb.resolve(str(args.get("term", "")))
+        if not concept:
+            return _error(f"未找到术语：{args.get('term', '')}")
+        return _text({k: concept.get(k) for k in (
+            "id", "term", "en", "aliases", "category", "kind", "parent",
+            "definition", "short_definition", "status", "sources", "evidence", "relations",
+        )})
+    if name == "mcai_search":
+        limit = int(args.get("limit", 8) or 8)
+        return _text({"query": args.get("query", ""),
+                      "results": kb.search(str(args.get("query", "")), limit=limit,
+                                           category=args.get("category"))})
+    if name == "mcai_related":
+        depth = int(args.get("depth", 1) or 1)
+        return _text(kb.related(str(args.get("term", "")), depth=depth))
+    if name == "mcai_list":
+        return _text(kb.catalog(args.get("category")))
+    return _error(f"未知工具：{name}")
+
+
+def handle(kb: knowledge.Knowledge, request: dict, tele=None) -> dict | None:
+    """处理单条 JSON-RPC 请求；通知类返回 None。"""
+    method = request.get("method", "")
+    req_id = request.get("id")
+    params = request.get("params") or {}
+
+    if method == "initialize":
+        return {"jsonrpc": "2.0", "id": req_id, "result": {
+            "protocolVersion": PROTOCOL_VERSION,
+            "capabilities": {"tools": {}, "resources": {}, "prompts": {}},
+            "serverInfo": SERVER_INFO,
+        }}
+    if method in ("notifications/initialized", "notifications/cancelled"):
+        return None
+    if method == "ping":
+        return {"jsonrpc": "2.0", "id": req_id, "result": {}}
+    if method == "tools/list":
+        return {"jsonrpc": "2.0", "id": req_id, "result": {"tools": TOOLS}}
+    if method == "tools/call":
+        name = params.get("name", "")
+        args = params.get("arguments") or {}
+        try:
+            result = call_tool(kb, name, args)
+            if tele is not None:
+                query = str(args.get("question") or args.get("term") or args.get("query") or "")
+                rtype = ""
+                if name == "mcai_answer" and not result.get("isError"):
+                    try:
+                        rtype = json.loads(result["content"][0]["text"]).get("type", "")
+                    except (json.JSONDecodeError, KeyError, IndexError):
+                        rtype = ""
+                tele.record("mcp", name, query, rtype, ok=not result.get("isError", False))
+            return {"jsonrpc": "2.0", "id": req_id, "result": result}
+        except Exception as exc:  # noqa: BLE001
+            return {"jsonrpc": "2.0", "id": req_id,
+                    "result": _error(f"工具执行失败：{type(exc).__name__}: {exc}")}
+    if method == "prompts/list":
+        return {"jsonrpc": "2.0", "id": req_id, "result": {"prompts": PROMPTS}}
+    if method == "prompts/get":
+        name = params.get("name", "")
+        args = params.get("arguments") or {}
+        if name == "explain_concept":
+            term = args.get("term", "元意识")
+            text = (f"请调用 mcai_concept 获取「{term}」的定义与引证，然后用该学说的术语解释它。"
+                    f"必须先说明它不是什么（若有消歧信息），再给出定义。")
+        elif name == "analyze_phenomenon":
+            phenomenon = args.get("phenomenon", "")
+            text = (f"请先用 mcai_search 检索与「{phenomenon}」相关的术语，"
+                    f"再用 mcai_answer 获取定义与出处，最后用该学说框架分析这个现象。"
+                    f"引用必须带出处，不确定时说明知识库未涉及。")
+        elif name == "compare_terms":
+            text = (f"请分别调用 mcai_concept 获取「{args.get('a', '')}」与「{args.get('b', '')}」的定义，"
+                    f"再调用 mcai_related 查看两者关系，最后按「相同点 / 不同点 / 关系类型」作答。")
+        else:
+            return {"jsonrpc": "2.0", "id": req_id,
+                    "error": {"code": -32602, "message": f"未知 prompt：{name}"}}
+        return {"jsonrpc": "2.0", "id": req_id, "result": {
+            "description": next((p["description"] for p in PROMPTS if p["name"] == name), ""),
+            "messages": [{"role": "user", "content": {"type": "text", "text": text}}],
+        }}
+    if method == "resources/list":
+        resources = [{
+            "uri": "mcai://guide",
+            "name": "Agent 接入指南",
+            "description": "何时调用、返回结构、术语边界与引用规范",
+            "mimeType": "text/markdown",
+        }] + [
+            {
+                "uri": f"mcai://concepts/{c['slug']}",
+                "name": c["term"],
+                "description": c.get("short_definition", ""),
+                "mimeType": "text/markdown",
+            }
+            for c in kb.concepts
+        ]
+        return {"jsonrpc": "2.0", "id": req_id, "result": {"resources": resources}}
+    if method == "resources/read":
+        uri = params.get("uri", "")
+        if uri == "mcai://guide":
+            from .guide import build_guide
+            return {"jsonrpc": "2.0", "id": req_id, "result": {"contents": [{
+                "uri": uri, "mimeType": "text/markdown",
+                "text": build_guide(kb, kb.payload.get("meta", {}).get("project", {})),
+            }]}}
+        slug = uri.rsplit("/", 1)[-1] if uri.startswith("mcai://concepts/") else uri
+        concept = kb.by_slug.get(slug)
+        if not concept:
+            return {"jsonrpc": "2.0", "id": req_id,
+                    "error": {"code": -32602, "message": f"未知资源：{uri}"}}
+        return {"jsonrpc": "2.0", "id": req_id, "result": {"contents": [{
+            "uri": uri,
+            "mimeType": "text/markdown",
+            "text": _concept_markdown(concept),
+        }]}}
+    return {"jsonrpc": "2.0", "id": req_id,
+            "error": {"code": -32601, "message": f"不支持的方法：{method}"}}
+
+
+def _concept_markdown(c: dict) -> str:
+    lines = [f"# {c['term']}", ""]
+    if c.get("en"):
+        lines.append(f"*{c['en']}*")
+    if c.get("aliases"):
+        lines.append(f"别名：{'、'.join(c['aliases'])}")
+    lines += ["", c["definition"], "", f"分类：{c['category']}"]
+    if c.get("parent"):
+        lines.append(f"衍生自：{c['parent']}")
+    if c.get("sources"):
+        lines += ["", "## 定义来源"]
+        lines += [f"- {s['doc_title']}（{s.get('section', '')}）" for s in c["sources"]]
+    if c.get("evidence"):
+        lines += ["", "## 文献引证"]
+        lines += [f"- 「{e['quote']}」——{e['doc_title']}" for e in c["evidence"][:3]]
+    if c.get("relations"):
+        lines += ["", "## 相关概念"]
+        lines += [f"- {r['target']}（{r['type']}）" for r in c["relations"][:10]]
+    return "\n".join(lines)
+
+
+def main(root: str | Path) -> None:
+    from .telemetry import for_root
+    kb = knowledge.load(root)
+    tele = for_root(root)
+    for line in sys.stdin:
+        line = line.strip()
+        if not line:
+            continue
+        try:
+            request = json.loads(line)
+        except json.JSONDecodeError:
+            print(json.dumps({"jsonrpc": "2.0", "id": None,
+                              "error": {"code": -32700, "message": "JSON 解析失败"}}, ensure_ascii=False),
+                  flush=True)
+            continue
+        response = handle(kb, request, tele)
+        if response is not None:
+            print(json.dumps(response, ensure_ascii=False), flush=True)
+
+
+def main_entry() -> None:
+    """控制台入口（mcai-mcp）：按 MCAI_HOME / 当前目录解析工作区。"""
+    from .workspace import resolve_home
+    main(resolve_home(None))

mcai/pdftext.py

@@ -0,0 +1,214 @@
+"""轻量 PDF 文本抽取：支持 Type0 + ToUnicode 的常见导出（WPS/Word）。
+
+只依赖标准库；按文本基线重建行，保持流式阅读顺序。
+"""
+from __future__ import annotations
+
+import re
+import zlib
+
+_OBJ = re.compile(rb"(\d+)\s+(\d+)\s+obj\b")
+
+
+def _objects(data: bytes) -> dict[int, bytes]:
+    spans = list(_OBJ.finditer(data))
+    out: dict[int, bytes] = {}
+    for i, m in enumerate(spans):
+        start = m.end()
+        end = data.find(b"endobj", start)
+        if end == -1:
+            end = spans[i + 1].start() if i + 1 < len(spans) else len(data)
+        out[int(m.group(1))] = data[start:end]
+    return out
+
+
+def _stream(body: bytes) -> bytes | None:
+    m = re.search(rb"stream\r?\n", body)
+    if not m:
+        return None
+    head, raw = body[: m.start()], body[m.end():]
+    end = raw.rfind(b"endstream")
+    if end != -1:
+        raw = raw[:end]
+    raw = raw.rstrip(b"\r\n")
+    if b"FlateDecode" in head:
+        for candidate in (raw, raw.rstrip(b"\n").rstrip(b"\r")):
+            try:
+                return zlib.decompress(candidate)
+            except zlib.error:
+                continue
+        return None
+    return raw
+
+
+def _utf16(hexstr: bytes | str) -> str:
+    h = hexstr.decode("ascii") if isinstance(hexstr, bytes) else hexstr
+    if len(h) % 4:
+        h = h.zfill((len(h) // 4 + 1) * 4)
+    try:
+        return bytes.fromhex(h).decode("utf-16-be")
+    except (ValueError, UnicodeDecodeError):
+        return ""
+
+
+def _cmap(text: bytes) -> dict[int, str]:
+    table: dict[int, str] = {}
+    for block in re.findall(rb"beginbfchar(.*?)endbfchar", text, re.S):
+        for src, dst in re.findall(rb"<([0-9A-Fa-f]+)>\s*<([0-9A-Fa-f]+)>", block):
+            table[int(src, 16)] = _utf16(dst)
+    for block in re.findall(rb"beginbfrange(.*?)endbfrange", text, re.S):
+        pattern = rb"<([0-9A-Fa-f]+)>\s*<([0-9A-Fa-f]+)>\s*(<[0-9A-Fa-f]+>|\[[^\]]*\])"
+        for m in re.finditer(pattern, block, re.S):
+            lo, hi, dst = int(m.group(1), 16), int(m.group(2), 16), m.group(3)
+            if dst.startswith(b"["):
+                for k, item in enumerate(re.findall(rb"<([0-9A-Fa-f]+)>", dst)):
+                    if lo + k > hi:
+                        break
+                    table[lo + k] = _utf16(item)
+            else:
+                base = _utf16(dst[1:-1])
+                for code in range(lo, hi + 1):
+                    if not base:
+                        table[code] = ""
+                    elif code == lo:
+                        table[code] = base
+                    else:
+                        table[code] = base[:-1] + chr(ord(base[-1]) + code - lo)
+    return table
+
+
+_TOKEN = re.compile(
+    rb"""
+      /(?P<font>[A-Za-z0-9_.+-]+)\s+(?P<fsize>[\d.]+)\s+Tf
+    | (?P<e>-?[\d.]+)\s+(?P<f>-?[\d.]+)\s+Tm
+    | (?P<ty>-?[\d.]+)\s+(?P<tdop>Td|TD)
+    | (?P<tj>\[(?P<arr>[^\]]*)\]\s*TJ)
+    | (?P<tj1>\((?:\\.|[^\\)])*\)\s*Tj)
+    | (?P<tj2><[0-9A-Fa-f\s]*>\s*Tj)
+    """,
+    re.S | re.X,
+)
+
+
+def _decode_hex(value: bytes, table: dict[int, str]) -> str:
+    h = re.sub(rb"\s", b"", value).decode("ascii")
+    if len(h) % 2:
+        h += "0"
+    raw = bytes.fromhex(h)
+    return "".join(table.get((raw[i] << 8) | raw[i + 1], "") for i in range(0, len(raw) - 1, 2))
+
+
+def _decode_lit(value: bytes, table: dict[int, str]) -> str:
+    s = value.replace(rb"\(", b"(").replace(rb"\)", b")").replace(rb"\\", b"\\")
+    if len(s) % 2:
+        return s.decode("latin1", "replace")
+    return "".join(table.get((s[i] << 8) | s[i + 1], "") for i in range(0, len(s) - 1, 2))
+
+
+def _fonts(res: bytes) -> dict[str, int]:
+    out: dict[str, int] = {}
+    m = re.search(rb"/Font\s*<<(.*?)>>", res, re.S)
+    if m:
+        for name, num in re.findall(rb"/([A-Za-z0-9_.+-]+)\s+(\d+)\s+0\s+R", m.group(1)):
+            out[name.decode()] = int(num)
+    return out
+
+
+def _pages(objects: dict[int, bytes]) -> list[int]:
+    catalog = next((n for n, b in objects.items() if re.search(rb"/Type\s*/Catalog", b)), None)
+    found: list[int] = []
+
+    def walk(num: int) -> None:
+        body = objects.get(num, b"")
+        if re.search(rb"/Type\s*/Pages", body):
+            kids = re.search(rb"/Kids\s*\[(.*?)\]", body, re.S)
+            if kids:
+                for k in re.findall(rb"(\d+)\s+0\s+R", kids.group(1)):
+                    walk(int(k))
+        elif re.search(rb"/Type\s*/Page\b", body):
+            found.append(num)
+
+    if catalog is not None:
+        root = re.search(rb"/Pages\s+(\d+)\s+0\s+R", objects[catalog])
+        if root:
+            walk(int(root.group(1)))
+    return found
+
+
+def extract_pdf_text(path: str) -> list[str]:
+    """返回每一页的文本（按行）。"""
+    data = open(path, "rb").read()
+    objects = _objects(data)
+
+    cmaps: dict[int, dict[int, str]] = {}
+    for num, body in objects.items():
+        ref = re.search(rb"/ToUnicode\s+(\d+)\s+0\s+R", body)
+        if ref:
+            raw = _stream(objects.get(int(ref.group(1)), b""))
+            if raw:
+                cmaps[num] = _cmap(raw)
+
+    pages_out: list[str] = []
+    for page in _pages(objects):
+        body = objects[page]
+        res = b""
+        ref = re.search(rb"/Resources\s+(\d+)\s+0\s+R", body)
+        if ref:
+            res = objects.get(int(ref.group(1)), b"")
+        else:
+            inline = re.search(rb"/Resources\s*<<(.*)", body, re.S)
+            if inline:
+                res = inline.group(1)
+        font_map = _fonts(res)
+
+        refs: list[int] = []
+        one = re.search(rb"/Contents\s+(\d+)\s+0\s+R", body)
+        if one:
+            refs = [int(one.group(1))]
+        else:
+            many = re.search(rb"/Contents\s*\[(.*?)\]", body, re.S)
+            if many:
+                refs = [int(x) for x in re.findall(rb"(\d+)\s+0\s+R", many.group(1))]
+        stream = b"".join((_stream(objects.get(r, b"")) or b"") + b"\n" for r in refs)
+
+        y = 0.0
+        last_y: float | None = None
+        table: dict[int, str] = {}
+        buf: list[str] = []
+        for m in _TOKEN.finditer(stream):
+            if m.group("font"):
+                table = cmaps.get(font_map.get(m.group("font").decode(), -1), {})
+            elif m.group("f") is not None:
+                y = float(m.group("f"))
+            elif m.group("tdop"):
+                y += float(m.group("ty"))
+            elif m.group("tj") or m.group("tj1") or m.group("tj2"):
+                if m.group("tj"):
+                    text = ""
+                    parts = re.findall(rb"<([0-9A-Fa-f\s]*)>|\(((?:\\.|[^\\)])*)\)|(-?[\d.]+)", m.group("arr"), re.S)
+                    for hx, lit, num in parts:
+                        if hx:
+                            text += _decode_hex(hx, table)
+                        elif lit:
+                            text += _decode_lit(lit, table)
+                        elif num and float(num) < -120:
+                            text += " "
+                else:
+                    raw = (m.group("tj1") or m.group("tj2"))
+                    raw = raw[: raw.rfind(b"Tj")]
+                    hm = re.search(rb"<([0-9A-Fa-f\s]*)>", raw)
+                    if hm:
+                        text = _decode_hex(hm.group(1), table)
+                    else:
+                        lm = re.search(rb"\(((?:\\.|[^\\)])*)\)", raw, re.S)
+                        text = _decode_lit(lm.group(1), table) if lm else ""
+                if not text:
+                    continue
+                if last_y is not None and abs(y - last_y) > 3.0:
+                    buf.append("\n")
+                last_y = y
+                buf.append(text)
+        raw_text = "".join(buf)
+        lines = [re.sub(r"[ \t]+", " ", ln).strip() for ln in raw_text.split("\n")]
+        pages_out.append("\n".join(ln for ln in lines if ln))
+    return pages_out