linxsci-sdk 0.3.0__py3-none-any.whl

linxsci/SKILL.md

@@ -0,0 +1,97 @@
+---
+name: linxsci-skills
+description: 调用 LinxSci Scholar OpenAPI v2，支持文献检索、论文内容与引用、推荐、学术实体和 PDF 解析。用于 Scholar 研究任务、指定接口调用，以及服务健康和用量查询。
+---
+
+# LinxSci Scholar
+
+使用本 Skill 的统一入口 `scripts/cli.py`。所有示例中的 `<skill-dir>` 都替换为本文件所在目录的绝对路径；脚本仅依赖 Python 3.9+ 标准库，无需安装 SDK。
+
+## 接口调用入口
+
+本 Skill 可调用 [接口文档](references/api.md) 中的全部 34 个接口，覆盖服务信息与健康、各来源搜索和标识解析、论文详情与引用、推荐、作者/机构/期刊及 PDF 解析。全部接口都提供便捷命令，按 [命令速查](references/cli.md) 选择；`request` 保留作通用调试入口。
+
+用户指定接口或操作时，按目标路由、参数和响应直接执行；例如查询用量不需要先检索论文，调用推荐接口不需要先走章节阅读流程。按任务需要读取接口文档，使用 `routes` 查看支持的方法与路径（不联网）。
+
+```bash
+python3 <skill-dir>/scripts/cli.py health ready
+python3 <skill-dir>/scripts/cli.py usage
+python3 <skill-dir>/scripts/cli.py search-openalex "large language models"
+python3 <skill-dir>/scripts/cli.py recommend --body @recommendations.json
+python3 <skill-dir>/scripts/cli.py resolve-entities --body @entities.json
+```
+
+四个搜索命令都直接接收检索词，可选 `--body` 提供附加 JSON 对象，检索词以位置参数为准。示例中的 JSON 文件须先按部署环境的 Agent API 契约或用户提供的参数准备。便捷命令自动选择方法和路径；JSON 请求使用 `--body @file.json`，PDF 上传接口 `/pdf/parse/upload` 使用 `upload /absolute/path/paper.pdf`，由脚本构造 multipart 的 `file` 字段。接口调用不要求助手额外完成综述或研究分析。
+
+## 配置与发现
+
+脚本优先读取环境变量 `SCHOLAR_BASE_URL` 和 `SCHOLAR_OPENAPI_KEY`，其次读取 `setup` 保存的用户本地配置。地址默认值是正式服务 `https://linxsci.com`，可显式配置其他部署地址；服务根地址不含 `/openapi/v2`。已有配置优先于发行默认值，升级不会自动切换用户保存的地址。不要读取、展示或让用户把 Key 发到对话。缺少配置时请用户在本机运行向导，Key 通过隐藏输入保存：
+
+```bash
+python3 <skill-dir>/scripts/cli.py setup
+# 线上地址作为默认提示：
+python3 <skill-dir>/scripts/cli.py setup --online
+```
+
+不要把服务端的 `AGENT_PUBLIC_API_KEY` 当成客户端 Key。`config` 仅显示配置状态，`config --clear` 清除保存的配置；执行清除需来自用户请求。
+
+```bash
+python3 <skill-dir>/scripts/cli.py doctor
+# 需要元信息正文时再调用：
+python3 <skill-dir>/scripts/cli.py meta
+python3 <skill-dir>/scripts/cli.py routes
+```
+
+首次接入可用 `doctor`（调用 `/meta`）验证连接；它也经过用量检查和计费流程，已有有效连接结果时不重复探测。根据 [接口文档](references/api.md) 核对目标路由；对于未定义的业务请求模型，读取部署环境的上游契约或用户提供的请求 JSON。`meta` 不保证返回完整 schema；缺少目标接口必需的业务参数时，说明需要补充的契约或请求 JSON，不猜测字段和分页，也不擅自改为其他接口任务。
+
+## 文献工作流
+
+```bash
+python3 <skill-dir>/scripts/cli.py search 'graph neural networks'
+python3 <skill-dir>/scripts/cli.py paper 'arxiv:2301.07041'
+python3 <skill-dir>/scripts/cli.py paper 'arxiv:2301.07041' --resource toc
+python3 <skill-dir>/scripts/cli.py paper 'arxiv:2301.07041' --resource sections --item-id '<returned-section-id>'
+```
+
+从搜索结果中取实际论文 ID；先看详情、目录，再读取相关章节，需要完整文本时才读 `--resource content`。论文 ID 需要 `local:`、`arxiv:`、`openalex:`、`s2:` 或 `doi:` 前缀。便捷命令接收未经编码的 ID（例如 `doi:10.1000/example`），SDK 负责编码。章节和资源 ID 必须取自返回结果。
+
+回答研究问题时由助手综合已读取内容，附上实际返回的论文标识、链接和章节依据。区分摘要和全文证据，说明缺失内容；不要声称存在服务端 `ask`、趋势榜或自动综述接口。
+
+## 其他接口与 PDF
+
+全部接口优先使用 [便捷命令速查](references/cli.md)，无需填写 HTTP 方法和路径。各来源检索、推荐、实体和 PDF 创建任务也都有独立命令。
+
+```bash
+python3 <skill-dir>/scripts/cli.py resolve --body @resolve.json
+python3 <skill-dir>/scripts/cli.py author '<returned-author-id>' --papers --param '<upstream-key>=<value>'
+python3 <skill-dir>/scripts/cli.py upload /absolute/path/paper.pdf
+python3 <skill-dir>/scripts/cli.py task '<returned-task-id>'
+python3 <skill-dir>/scripts/cli.py task '<returned-task-id>' --result
+python3 <skill-dir>/scripts/cli.py --output /absolute/path/asset.bin paper 'arxiv:2301.07041' --resource assets --item-id '<returned-asset-id>'
+```
+
+全局可选参数 `--framework-request-id <id>`（放在 `linxsci` 之后、具体动作之前）发送 `X-ANYTHINGRIGHT-REQ-ID`，对应 Scholar 自身错误的 `extra.request-id`；各接口命令的 `--request-id <id>` 发送独立的 `X-Request-ID`。两者用途不同。通用 `request` 的路径相对于 `/openapi/v2`，每个动态 ID 独立 URL 编码（包括 DOI 中的斜杠）；查询参数用重复的 `--param key=value`。JSON 通过 `--body @file.json` 原样传入。`upload` 可传 `--field key=value`；上游契约需要 `X-MinerU-API-Key` 时，在本机设置 `SCHOLAR_MINERU_API_KEY`，`parse-pdf`、`upload`、`task`（含 `--result`）及通用 PDF `request` 都会读取它。
+
+上传会发送本地文件到配置服务，仅在用户请求解析该文件时执行。任务状态结构未定义，使用实际返回的标识和状态；不自动无限轮询或重复创建任务，确认完成后获取结果。
+
+## 输出与故障
+
+stdout 输出 JSON 或原始响应；`--output`（放在 `linxsci` 之后、具体动作之前）保留响应原始字节，适用于二进制资源。SDK `Response` 保留 status、headers、body。上游响应原样透传，Scholar 自身错误则使用 `code/data/error/extra` 框架结构；读取 `error.code` 和 `extra.request-id`，不把它当作上游业务模型。`extra.cost` 是请求耗时（秒），不是扣费金额。不要假定列表字段或 PDF 终态。
+
+退出码：0 成功，1 HTTP/网络错误，2 参数/本地文件错误。SDK 异常保留原始错误体，并提供 `error_code`、`request_id`、`framework_request_id`、`execution_uncertain` 属性。CLI 默认输出中文诊断和两种请求 ID；`linxsci --json-errors` 输出结构化诊断，不展示服务端错误消息全文。
+
+按 HTTP 状态和实际 `error.code` 区分故障：
+
+| error.code | 处理 |
+| --- | --- |
+| `-401` / `-404` | 检查 Scholar Key / 路径和方法 |
+| `-3900` | action 已登记但未启用，联系管理员配置并启用；不要反复重试 |
+| `-3901` | 每日调用限额已满，额度恢复后或管理员处理后再调用 |
+| `-3902` | 服务端 Agent API 地址或 Key 缺失，联系管理员 |
+| `-3903` | 上游连接/传输失败，检查连接；不要将失败等同于业务操作一定未执行 |
+| `-3904` | member begin 未成功，未转发上游，交由管理员排查 |
+| `-3905` | 上游已返回但 finish 未确认，先查询执行与计费结果，再决定是否重试，尤其不要直接重复上传或创建解析任务 |
+
+上游业务错误（例如 `validation_error`、`asset_unavailable`）保留其原有格式；不要把全部 502/503 当作相同原因。脚本不自动重试；保留 `Retry-After`，但它不能替代 `-3905` 的执行/计费核查。
+
+每次请求预计调用量为 1，Agent API 2xx 对应实际调用量 1，其他状态或连接失败对应 0，预占释放由 member finish 结果确认。不要根据 HTTP 失败自行保证扣费已经释放，尤其遇到 `-3905`。避免无目的的重复检索、诊断与轮询；查询动作也走调用限额。详细规则见 [references/api.md](references/api.md)。

linxsci/__init__.py

@@ -0,0 +1,5 @@
+"""LinxSci Scholar SDK and self-contained Agent Skill."""
+from .scripts.scholar_client import Response, ScholarClient, ScholarError
+
+__version__ = "0.3.0"
+__all__ = ["Response", "ScholarClient", "ScholarError"]

linxsci/agents/openai.yaml

@@ -0,0 +1,4 @@
+interface:
+  display_name: "LinxSci Skills"
+  short_description: "调用 Scholar 全部 OpenAPI 接口，支持论文检索、引用、推荐、学术实体和 PDF 解析"
+  default_prompt: "使用 $linxsci-skills 检索指定主题的论文，阅读相关章节并给出有来源依据的总结。"

linxsci/references/api.md

@@ -0,0 +1,105 @@
+# Scholar OpenAPI v2 使用文档
+
+Scholar 的 `/openapi/v2` 将请求转发给独立 Agent API。客户端只需使用 Scholar API Key；服务端负责向 Agent API 提供自己的 Key。接口路径、业务请求参数和上游业务响应以 Agent API 的 `/openapi/v1` 契约为准。健康检查分别转发到 Agent API 的 `/health/live` 和 `/health/ready`。
+
+可直接导入 [Postman 集合](./Scholar-OpenAPI-v2.postman_collection.json) 调用下表中的接口。
+
+## 认证和配置
+
+| 请求头 | 提供方 | 用途 |
+| --- | --- | --- |
+| `Authorization: Bearer <Scholar OpenAPI Key>` | 客户端 | Scholar 校验 API Key，所有 v2 接口都需要。 |
+| `X-Request-ID` | 客户端，可选 | 转发给 Agent API；Scholar 自身返回错误时也会在响应头回传。 |
+| `X-ANYTHINGRIGHT-REQ-ID` | 客户端，可选 | 指定 Scholar 框架响应中的 `extra.request-id`；未提供时由框架生成。 |
+| `X-MinerU-API-Key` | 客户端，按需 | PDF 解析相关请求转发给 Agent API。 |
+
+Scholar 服务端配置 `AgentPublicServerIp` 和 `AgentPublicAPIKey`；相应环境变量 `AGENT_PUBLIC_API_URL`、`AGENT_PUBLIC_API_KEY` 可在配置项为空时使用。转发到 Agent API `/openapi/v1` 的请求会由服务端附加 `X-API-Key`，客户端无需提供第二把 Key。v2 的这组配置与旧版 Agent API 配置独立。
+
+## 接口目录
+
+以下为 Scholar 对外路径。除健康检查外，上游使用相同的 HTTP 方法及 `/openapi/v1` 路径前缀。
+
+| Postman 分类 | 方法 | Scholar 路径 | 接口 |
+| --- | --- | --- | --- |
+| 服务信息与健康检查 | GET | `/openapi/v2/meta` | 接口元信息 |
+| 服务信息与健康检查 | GET | `/openapi/v2/usage` | 用量信息 |
+| 服务信息与健康检查 | GET | `/openapi/v2/health/live` | 存活检查 |
+| 服务信息与健康检查 | GET | `/openapi/v2/health/ready` | 就绪检查 |
+| 论文搜索与解析 | POST | `/openapi/v2/papers/search` | 综合论文搜索 |
+| 论文搜索与解析 | POST | `/openapi/v2/search/openalex` | OpenAlex 搜索 |
+| 论文搜索与解析 | POST | `/openapi/v2/search/semantic-scholar` | Semantic Scholar 搜索 |
+| 论文搜索与解析 | POST | `/openapi/v2/search/google-scholar` | Google Scholar 搜索 |
+| 论文搜索与解析 | POST | `/openapi/v2/papers/resolve` | 论文标识解析 |
+| 论文搜索与解析 | POST | `/openapi/v2/papers:batchGet` | 批量获取论文 |
+| 论文详情与引用 | GET | `/openapi/v2/papers/{paper_id}` | 论文详情 |
+| 论文详情与引用 | GET | `/openapi/v2/papers/{paper_id}/content` | 论文内容 |
+| 论文详情与引用 | GET | `/openapi/v2/papers/{paper_id}/toc` | 论文目录 |
+| 论文详情与引用 | GET | `/openapi/v2/papers/{paper_id}/sections/{section_id}` | 论文章节 |
+| 论文详情与引用 | GET | `/openapi/v2/papers/{paper_id}/figures` | 论文图表 |
+| 论文详情与引用 | GET | `/openapi/v2/papers/{paper_id}/assets/{asset_id}` | 论文资源 |
+| 论文详情与引用 | GET | `/openapi/v2/papers/{paper_id}/references` | 参考文献 |
+| 论文详情与引用 | GET | `/openapi/v2/papers/{paper_id}/citations` | 被引论文 |
+| 论文详情与引用 | GET | `/openapi/v2/papers/{paper_id}/related` | 相关论文 |
+| 论文详情与引用 | GET | `/openapi/v2/papers/{paper_id}/graph` | 引用图谱 |
+| 论文详情与引用 | GET | `/openapi/v2/papers/{paper_id}/citation` | 论文引用格式 |
+| 论文推荐 | POST | `/openapi/v2/recommendations` | 论文推荐 |
+| 论文推荐 | GET | `/openapi/v2/recommendations/mobile-cards` | 移动端推荐卡片 |
+| 作者、机构与期刊 | GET | `/openapi/v2/authors/{author_id}` | 作者详情 |
+| 作者、机构与期刊 | GET | `/openapi/v2/authors/{author_id}/papers` | 作者论文 |
+| 作者、机构与期刊 | GET | `/openapi/v2/institutions/{institution_id}` | 机构详情 |
+| 作者、机构与期刊 | GET | `/openapi/v2/institutions/{institution_id}/papers` | 机构论文 |
+| 作者、机构与期刊 | GET | `/openapi/v2/venues/{venue_id}` | 期刊或会议详情 |
+| 作者、机构与期刊 | GET | `/openapi/v2/venues/{venue_id}/papers` | 期刊或会议论文 |
+| 作者、机构与期刊 | POST | `/openapi/v2/entities:resolve` | 实体标识解析 |
+| PDF 解析 | POST | `/openapi/v2/pdf/parse` | 创建 PDF 解析任务 |
+| PDF 解析 | POST | `/openapi/v2/pdf/parse/upload` | 上传 PDF 并创建解析任务 |
+| PDF 解析 | GET | `/openapi/v2/pdf/parse/{task_id}` | 查询 PDF 解析任务 |
+| PDF 解析 | GET | `/openapi/v2/pdf/parse/{task_id}/result` | 获取 PDF 解析结果 |
+
+`paper_id` 支持 `local:`、`arxiv:`、`openalex:`、`s2:`、`doi:` 前缀。ID 中的 `/` 需要 URL 编码，例如 `doi:10.1000%2Fexample`。`POST` 接口的 JSON 字段按 Agent API 契约填写；Postman 中的 `{}` 只是待编辑模板。PDF 上传使用 `multipart/form-data` 的 `file` 字段，具体参数与文件大小限制以 Agent API 配置为准。
+
+## API Key 调用与计费流程
+
+正常调用依次经过 Scholar 的 API Key 校验、member 的 `/internal/openapi/calls/begin`、Agent API 转发和 member 的 `/internal/openapi/calls/finish`。若服务端 Agent API 配置缺失，请求会在 `begin` 前返回；若 `begin` 拒绝请求，则不会转发上游或调用 `finish`。路由映射生成固定的 `openapi_v2_*` action，例如论文资源接口的 action 为 `openapi_v2_paper_asset`。
+
+首次调用尚未登记的 action 时，member 会在 `openapi_register` 创建**待启用**记录；该次请求返回 HTTP 503，且不会转发给 Agent API。管理员按免费或计费策略配置并启用对应 action 后，才能继续调用。
+
+每次请求预计调用量为 1。Agent API 返回 2xx 时，实际调用量为 1；返回其他状态或发生连接失败时，实际调用量为 0，member 根据 `finish` 结果释放预占积分。每日调用限额由 member 检查。
+
+## 响应与错误
+
+Agent API 已返回且 `finish` 成功时，Scholar 保留上游 HTTP 状态码和响应体，并透传 `Content-Type`、`X-Request-ID`、`Retry-After`、`Cache-Control`。这也适用于 Agent API 的业务错误，例如 `validation_error` 或 `asset_unavailable`；其错误体仍使用 Agent API 的格式。
+
+Scholar 自身产生的鉴权、配置、用量和连接错误使用统一框架结构：
+
+```json
+{
+  "code": -1,
+  "data": {},
+  "error": {
+    "code": -3900,
+    "msg": "OpenAPI action openapi_v2_paper_asset has been registered but is not enabled. Ask an administrator to configure and enable it before retrying."
+  },
+  "extra": {
+    "request-id": "example-request-id",
+    "cost": 0.01
+  }
+}
+```
+
+示例中的 HTTP 状态为 503；`extra.cost` 是本次请求耗时，单位为秒。这里的 `extra.request-id` 来自 `X-ANYTHINGRIGHT-REQ-ID` 或由框架生成。member 内部使用的 `-3501`、`-3500` 会分别转换为下表的对外错误码。
+
+| HTTP | `error.code` | 原因与处理 |
+| --- | --- | --- |
+| 401 | `-401` | Scholar API Key 缺失、无效或无法识别用户；检查 `Authorization`。 |
+| 404 | `-404` | 未匹配到 v2 接口映射；检查路径和 HTTP 方法。 |
+| 503 | `-3900` | 接口 action 已登记但未启用；联系管理员配置、启用后重试。 |
+| 429 | `-3901` | 已达到每日调用限额；额度恢复后重试或联系管理员。 |
+| 503 | `-3902` | Agent API 地址或服务端 Key 未配置；联系服务端管理员。 |
+| 502 | `-3903` | Agent API 连接或传输失败；Scholar 会尝试以失败结果调用 `finish`。 |
+| 502 | `-3904` | member 的 `begin` 未成功，尚未转发上游；检查 member 服务和内部鉴权配置。 |
+| 502 | `-3905` | Agent API 已返回，但 member 的 `finish` 未确认；先查询执行与计费结果，再决定是否重试可能产生写入的请求。 |
+
+## Postman 调用
+
+导入 [Scholar OpenAPI v2 集合](./Scholar-OpenAPI-v2.postman_collection.json)，设置 `scholar_base_url` 和 `scholar_api_key`。GET 请求可直接按路径变量调用；POST 请求先按 Agent API 契约填写 JSON。调用 `/openapi/v2/pdf/parse/upload` 时，在 Postman 的 `file` 字段中选择本地 PDF。

linxsci/references/cli.md

@@ -0,0 +1,46 @@
+# 全接口便捷命令
+
+全部 34 个接口都可直接调用，无需指定 HTTP 方法或接口路径。已安装 CLI 时使用下表的 `linxsci`；仅安装 Skill 时，替换为 `python3 <skill-dir>/scripts/cli.py`。
+
+动态 ID 使用响应返回的原始值，由 CLI 自动编码。表中的尖括号是占位参数，须替换。JSON 文件需按实际 Agent API 契约准备；四个搜索命令把检索词发送为 `query`，可选 `--body` 只提供附加参数，不能覆盖位置参数中的检索词；不推断其他业务字段。`{}` 不是通用有效业务请求。
+
+| 编号 | 接口 | 命令 |
+| --- | --- | --- |
+| 01 | 接口元信息 | `linxsci meta` |
+| 02 | 用量信息 | `linxsci usage` |
+| 03 | 存活检查 | `linxsci health live` |
+| 04 | 就绪检查 | `linxsci health ready` |
+| 05 | 综合论文搜索 | `linxsci search "large language models"` |
+| 06 | OpenAlex 搜索 | `linxsci search-openalex "large language models"` |
+| 07 | Semantic Scholar 搜索 | `linxsci search-semantic-scholar "large language models"` |
+| 08 | Google Scholar 搜索 | `linxsci search-google-scholar "large language models"` |
+| 09 | 论文标识解析 | `linxsci resolve --body @papers-resolve.json` |
+| 10 | 批量获取论文 | `linxsci batch-get --body @papers-batch-get.json` |
+| 11 | 论文详情 | `linxsci paper "<paper-id>"` |
+| 12 | 论文内容 | `linxsci paper "<paper-id>" --resource content` |
+| 13 | 论文目录 | `linxsci paper "<paper-id>" --resource toc` |
+| 14 | 论文章节 | `linxsci paper "<paper-id>" --resource sections --item-id "<section-id>"` |
+| 15 | 论文图表 | `linxsci paper "<paper-id>" --resource figures` |
+| 16 | 论文资源 | `linxsci --output asset.bin paper "<paper-id>" --resource assets --item-id "<asset-id>"` |
+| 17 | 参考文献 | `linxsci paper "<paper-id>" --resource references` |
+| 18 | 被引论文 | `linxsci paper "<paper-id>" --resource citations` |
+| 19 | 相关论文 | `linxsci paper "<paper-id>" --resource related` |
+| 20 | 引用图谱 | `linxsci paper "<paper-id>" --resource graph` |
+| 21 | 论文引用格式 | `linxsci paper "<paper-id>" --resource citation` |
+| 22 | 论文推荐 | `linxsci recommend --body @recommendations.json` |
+| 23 | 移动端推荐卡片 | `linxsci mobile-cards` |
+| 24 | 作者详情 | `linxsci author "<author-id>"` |
+| 25 | 作者论文 | `linxsci author "<author-id>" --papers` |
+| 26 | 机构详情 | `linxsci institution "<institution-id>"` |
+| 27 | 机构论文 | `linxsci institution "<institution-id>" --papers` |
+| 28 | 期刊或会议详情 | `linxsci venue "<venue-id>"` |
+| 29 | 期刊或会议论文 | `linxsci venue "<venue-id>" --papers` |
+| 30 | 实体标识解析 | `linxsci resolve-entities --body @entities-resolve.json` |
+| 31 | 创建 PDF 解析任务 | `linxsci parse-pdf --body @pdf-parse.json` |
+| 32 | 上传 PDF 并创建解析任务 | `linxsci upload "/实际路径/paper.pdf"` |
+| 33 | 查询 PDF 解析任务 | `linxsci task "<task-id>"` |
+| 34 | 获取 PDF 解析结果 | `linxsci task "<task-id>" --result` |
+
+所有接口命令支持重复的 `--param key=value` 和 `--request-id`；`--output`、`--timeout`、`--framework-request-id`、`--json-errors` 放在动作之前。PDF 命令按需读取 `SCHOLAR_MINERU_API_KEY`。创建/上传任务后记录真实 ID，不自动重试或无限轮询。
+
+`linxsci <动作> --help` 可查看参数。`request` 保留作通用调试入口；该入口的动态 ID 需自行编码。接口定义和错误码见 [api.md](api.md)。

linxsci/scripts/__init__.py

@@ -0,0 +1 @@
+"""Executable helpers for the LinxSci Scholar Skill."""

linxsci/scripts/cli.py

@@ -0,0 +1,34 @@
+#!/usr/bin/env python3
+"""LinxSci 统一命令行入口，常用动作直接运行。"""
+import sys
+
+if __package__:
+    from .scholar import VERSION, build_parser, main as scholar_main
+else:
+    from scholar import VERSION, build_parser, main as scholar_main
+
+# Add a capability only after its command handler is implemented and packaged.
+# Handlers receive their own argv and a display name for argparse help/errors.
+CAPABILITIES = {}
+
+
+def main(argv=None):
+    argv = list(sys.argv[1:] if argv is None else argv)
+    if argv and argv[0] in CAPABILITIES:
+        # Forward unchanged, including options before the action and negative queries.
+        handler = CAPABILITIES[argv[0]][1]
+        return handler(argv[1:], prog="linxsci " + argv[0])
+    if not argv or argv in (["--help"], ["-h"]):
+        parser = build_parser(prog="linxsci")
+        extra = [name + "：" + description for name, (description, _) in CAPABILITIES.items()]
+        if extra:
+            parser.epilog = "扩展能力：" + "；".join(extra)
+        if not argv:
+            parser.print_help()
+            return 0
+        parser.parse_args(argv)  # argparse prints help and exits successfully.
+    return scholar_main(argv, prog="linxsci")
+
+
+if __name__ == "__main__":
+    sys.exit(main())

linxsci/scripts/scholar.py

@@ -0,0 +1,301 @@
+#!/usr/bin/env python3
+"""LinxSci Scholar：搜索论文、按章节阅读和解析 PDF；首次使用请运行 linxsci setup。"""
+import argparse
+import getpass
+import json
+import os
+import sys
+import warnings
+from pathlib import Path
+if __package__:
+    from .scholar_client import ROUTES, ScholarClient, ScholarError, paper_path, segment
+    from .scholar_config import config_path, clear_config, load_config, save_config, service_defaults, validate_url
+    from .scholar_install import install_skill
+else:
+    from scholar_client import ROUTES, ScholarClient, ScholarError, paper_path, segment
+    from scholar_config import config_path, clear_config, load_config, save_config, service_defaults, validate_url
+    from scholar_install import install_skill
+
+VERSION = "0.3.0"
+
+SEARCH_COMMANDS = {
+    "search": ("/papers/search", "综合论文搜索"),
+    "search-openalex": ("/search/openalex", "OpenAlex 搜索"),
+    "search-semantic-scholar": ("/search/semantic-scholar", "Semantic Scholar 搜索"),
+    "search-google-scholar": ("/search/google-scholar", "Google Scholar 搜索"),
+}
+JSON_COMMANDS = {
+    "resolve": ("/papers/resolve", "解析论文标识"),
+    "batch-get": ("/papers:batchGet", "批量获取论文"),
+    "recommend": ("/recommendations", "推荐论文"),
+    "resolve-entities": ("/entities:resolve", "解析作者、机构或期刊标识"),
+    "parse-pdf": ("/pdf/parse", "按 JSON 请求创建 PDF 解析任务"),
+}
+ENTITY_COMMANDS = {"author": "authors", "institution": "institutions", "venue": "venues"}
+
+
+def error_info(error):
+    code = error.error_code
+    hints = {
+        401: "API Key 无效或已过期，请运行 linxsci setup 重新配置。",
+        403: "账号无权调用此接口，请检查账号权限。",
+        404: "服务未提供此接口，请核对服务根地址和部署版本。",
+        429: "请求过于频繁或额度不足，请稍后重试或检查账号用量。",
+        502: "Scholar 无法连接上游服务，请联系服务维护者。",
+        503: "服务暂不可用，请稍后重试或联系服务维护者。",
+    }
+    message = hints.get(error.status, "服务调用失败，请检查服务地址、网络和服务状态。")
+    code_hints = {
+        -401: hints[401],
+        -404: hints[404],
+        -3900: "接口 action 已登记但未启用，请联系管理员配置并启用后再调用。",
+        -3901: "已达到每日调用限额，请在额度恢复后重试或联系管理员。",
+        -3902: "Agent API 地址或服务端 Key 未配置，请联系服务端管理员。",
+        -3903: "Agent API 连接或传输失败，请联系服务维护者检查连接。",
+        -3904: "member 的 begin 未成功，请求尚未转发上游；请联系管理员检查 member 服务和内部鉴权。",
+        -3905: "Agent API 已返回，但 member 的 finish 未确认。请先查询执行与计费结果，再决定是否重试；不要直接重复上传或创建任务。",
+        # Keep compatibility with older Scholar deployments.
+        "upstream_unconfigured": "Scholar 服务端上游配置不完整，请联系服务维护者。",
+    }
+    message = code_hints.get(code, message)
+    headers = {k.lower(): v for k, v in error.headers.items()}
+    # Only selected response metadata is exposed; never print the upstream error body.
+    return {"message": message, "status": error.status, "error_code": code,
+            "request_id": error.request_id, "framework_request_id": error.framework_request_id,
+            "execution_uncertain": error.execution_uncertain, "retry_after": headers.get("retry-after")}
+
+
+def print_error_details(report, stream):
+    if report.get("error_code") is not None:
+        print("错误码：" + str(report["error_code"]), file=stream)
+    if report.get("request_id"):
+        print("上游/代理请求 ID：" + report["request_id"], file=stream)
+    if report.get("framework_request_id"):
+        print("Scholar 框架请求 ID：" + report["framework_request_id"], file=stream)
+    if report.get("retry_after"):
+        print("Retry-After：" + report["retry_after"], file=stream)
+
+
+def doctor(client, as_json=False):
+    report = {"ok": False, "base_url": client.base_url, "key_configured": True,
+              "config_file": str(config_path())}
+    try:
+        response = client.request("GET", "/meta")
+        response.json()  # A 200 HTML login page is not a working API connection.
+        report.update(ok=True, status=response.status, message="连接成功，可以开始检索论文。")
+    except ScholarError as error:
+        report.update(error_info(error))
+    except (ValueError, UnicodeDecodeError):
+        report["message"] = "服务返回了非 JSON 内容，请核对根地址，排除登录页或代理页面。"
+    if as_json:
+        print(json.dumps(report, ensure_ascii=False, indent=2))
+    else:
+        print("服务地址：" + report["base_url"])
+        print(report["message"])
+        print_error_details(report, sys.stdout)
+    return 0 if report["ok"] else 1
+
+
+def setup(args):
+    defaults = service_defaults()
+    try:
+        saved = load_config()
+    except ValueError:
+        saved = {}  # setup can repair a corrupt configuration.
+    base_url = args.base_url
+    if not base_url:
+        base_url = defaults["online_base_url"] if args.online else saved.get("base_url", defaults["base_url"])
+    if not args.api_key_stdin:
+        if not sys.stdin.isatty():
+            raise ValueError("配置向导需要交互终端；自动配置请使用 --api-key-stdin。")
+        print("LinxSci Scholar 配置向导（API Key 输入不会显示）")
+        print("线上服务：" + defaults["online_base_url"])
+        base_url = input("服务根地址 [" + base_url + "]：").strip() or base_url
+        try:
+            with warnings.catch_warnings():
+                warnings.simplefilter("error", getpass.GetPassWarning)
+                key = getpass.getpass("请输入 API Key" + ("（留空保留已有 Key）" if saved.get("api_key") else "") + "：")
+        except getpass.GetPassWarning:
+            raise ValueError("当前终端无法隐藏 Key 输入，请在普通终端运行 setup。") from None
+        key = key or saved.get("api_key", "")
+    else:
+        key = sys.stdin.readline().rstrip("\r\n")
+    base_url = validate_url(base_url)
+    path = save_config(base_url, key)
+    print("配置已保存：" + str(path))
+    if os.environ.get("SCHOLAR_BASE_URL") or os.environ.get("SCHOLAR_OPENAPI_KEY"):
+        print("提示：后续调用时，已有环境变量优先于本地配置。")
+    if args.no_check:
+        print("已跳过连接检查。稍后运行 linxsci doctor 检查连接。")
+        return 0
+    return doctor(ScholarClient(base_url, key, timeout=args.timeout, framework_request_id=args.framework_request_id))
+
+
+def pairs(values):
+    result = {}
+    for value in values or []:
+        key, sep, val = value.partition("=")
+        if not sep or not key:
+            raise ValueError("Parameters must use key=value")
+        result.setdefault(key, []).append(val)
+    return result
+
+
+def build_parser(*, prog=None):
+    parser = argparse.ArgumentParser(prog=prog, description=__doc__)
+    parser.add_argument("--version", action="version", version=VERSION)
+    parser.add_argument("--json-errors", action="store_true", help="Output structured errors on stderr")
+    parser.add_argument("--timeout", type=float, default=60)
+    parser.add_argument("--framework-request-id", help="设置 X-ANYTHINGRIGHT-REQ-ID，用于定位 Scholar 框架请求")
+    sub = parser.add_subparsers(dest="command", required=True)
+    sub.add_parser("routes", help="列出已知接口，无需配置 Key")
+    configure = sub.add_parser("setup", help="首次配置服务地址和 API Key")
+    configure.add_argument("--base-url", help="Service root URL")
+    configure.add_argument("--online", action="store_true", help="Use linxsci.com as the suggested service")
+    configure.add_argument("--api-key-stdin", action="store_true", help="Read the Key from stdin without echoing it")
+    configure.add_argument("--no-check", action="store_true", help="Save settings without a network check")
+    diagnose = sub.add_parser("doctor", help="检查配置和服务连接")
+    diagnose.add_argument("--json", action="store_true")
+    configuration = sub.add_parser("config", help="查看配置状态（不显示 Key）或清除配置")
+    configuration.add_argument("--clear", action="store_true")
+    installer = sub.add_parser("install-skill", help="安装自包含 Skill，无需联网")
+    installer.add_argument("--skills-dir", help="Parent directory for the Skill (default: ~/.agents/skills)")
+    installer.add_argument("--update", action="store_true", help="Update a managed installation and retain a backup")
+    def api_command(name, help):
+        command = sub.add_parser(name, help=help, description=help)
+        command.add_argument("--param", action="append", help="查询参数 key=value，可重复；字段按上游契约")
+        command.add_argument("--request-id", help="上游/代理 X-Request-ID")
+        return command
+
+    for name, help in (("meta", "接口元信息"), ("usage", "用量信息"),
+                       ("mobile-cards", "移动端推荐卡片")):
+        api_command(name, help)
+    health = api_command("health", "存活或就绪检查")
+    health.add_argument("check", choices=("live", "ready"))
+    for name, (_, help) in JSON_COMMANDS.items():
+        command = api_command(name, help)
+        command.add_argument("--body", required=True, help="JSON 或 @文件.json，字段按上游契约")
+    for name in ENTITY_COMMANDS:
+        entity = api_command(name, {"author": "作者详情或论文", "institution": "机构详情或论文", "venue": "期刊/会议详情或论文"}[name])
+        entity.add_argument("entity_id", help="响应中的原始 ID，无需 URL 编码")
+        entity.add_argument("--papers", action="store_true", help="获取该实体的论文")
+    for name, (_, help) in SEARCH_COMMANDS.items():
+        search = api_command(name, help)
+        search.add_argument("query", help="检索词")
+        search.add_argument("--body", help="可选附加参数，JSON 对象或 @文件.json；字段按上游契约")
+    paper = api_command("paper", "读取论文详情、内容、目录、章节或引用等资源")
+    paper.add_argument("paper_id")
+    paper.add_argument("--resource", choices=("content", "toc", "sections", "figures", "assets", "references", "citations", "related", "graph", "citation"))
+    paper.add_argument("--item-id")
+    upload = api_command("upload", "上传 PDF 并创建解析任务")
+    upload.add_argument("file")
+    upload.add_argument("--field", action="append")
+    task = api_command("task", "查询 PDF 任务或结果")
+    task.add_argument("task_id")
+    task.add_argument("--result", action="store_true")
+    request = api_command("request", "通用接口调试入口；日常调用使用便捷命令")
+    request.add_argument("method", choices=("GET", "POST"))
+    request.add_argument("path", help="Encoded path relative to /openapi/v2")
+    request.add_argument("--body", help="JSON or @file; required for JSON POST")
+    parser.add_argument("--output", help="Write response bytes to a file (also supports binary assets)")
+    return parser
+
+
+def main(argv=None, *, prog=None):
+    parser = build_parser(prog=prog)
+    args = parser.parse_args(argv)
+    try:
+        if args.command == "setup":
+            return setup(args)
+        if args.command == "config":
+            if args.clear:
+                clear_config()
+                print("本地配置已清除；如设置了环境变量，请另行清除。")
+            else:
+                saved = load_config()
+                print(json.dumps({"config_file": str(config_path()),
+                                  "saved_base_url": saved.get("base_url"),
+                                  "saved_key_configured": bool(saved.get("api_key")),
+                                  "environment_url_override": bool(os.environ.get("SCHOLAR_BASE_URL")),
+                                  "environment_key_override": bool(os.environ.get("SCHOLAR_OPENAPI_KEY"))},
+                                 ensure_ascii=False, indent=2))
+            return 0
+        if args.command == "install-skill":
+            destination, backup = install_skill(args.skills_dir, args.update)
+            print("Skill 已安装：" + str(destination))
+            if backup:
+                print("旧版本备份：" + str(backup))
+            print("现在可在助手中使用 $linxsci-skills；如果没有显示，请重启助手。")
+            return 0
+        if args.command == "routes":
+            print(json.dumps(ROUTES, ensure_ascii=False, indent=2))
+            return 0
+        client = ScholarClient(timeout=args.timeout, framework_request_id=args.framework_request_id)
+        if args.command == "doctor":
+            return doctor(client, args.json)
+        def body(value):
+            return json.loads(Path(value[1:]).read_text(encoding="utf-8") if value.startswith("@") else value)
+        def invoke(method, path, **options):
+            return client.request(method, path, query=pairs(args.param), request_id=args.request_id,
+                                  mineru_key=os.environ.get("SCHOLAR_MINERU_API_KEY") if path.startswith("/pdf/parse") else None,
+                                  **options)
+        if args.command in ("meta", "usage"):
+            response = invoke("GET", "/" + args.command)
+        elif args.command == "mobile-cards":
+            response = invoke("GET", "/recommendations/mobile-cards")
+        elif args.command in JSON_COMMANDS:
+            response = invoke("POST", JSON_COMMANDS[args.command][0], payload=body(args.body))
+        elif args.command in ENTITY_COMMANDS:
+            path = "/" + ENTITY_COMMANDS[args.command] + "/" + segment(args.entity_id)
+            response = invoke("GET", path + ("/papers" if args.papers else ""))
+        elif args.command == "health":
+            response = invoke("GET", "/health/" + args.check)
+        elif args.command in SEARCH_COMMANDS:
+            options = body(args.body) if args.body else {}
+            if not isinstance(options, dict):
+                raise ValueError("Search body must be a JSON object")
+            options.pop("query", None)
+            response = invoke("POST", SEARCH_COMMANDS[args.command][0], payload={**options, "query": args.query})
+        elif args.command == "paper":
+            response = invoke("GET", paper_path(args.paper_id, args.resource, args.item_id))
+        elif args.command == "upload":
+            values = pairs(args.field)
+            if any(len(v) != 1 for v in values.values()):
+                raise ValueError("Form field names must be unique")
+            response = invoke("POST", "/pdf/parse/upload", file=args.file, fields={k: v[0] for k, v in values.items()})
+        elif args.command == "task":
+            if args.task_id == "upload":
+                raise ValueError("task_id cannot be upload")
+            response = invoke("GET", "/pdf/parse/" + segment(args.task_id) + ("/result" if args.result else ""))
+        else:
+            if args.method == "POST" and not args.body:
+                raise ValueError("JSON POST requires --body with the upstream request schema; use upload for files")
+            response = invoke(args.method, args.path, payload=body(args.body) if args.body else None)
+        if args.output:
+            Path(args.output).write_bytes(response.body)
+        else:
+            try:
+                print(json.dumps(response.json(), ensure_ascii=False, indent=2))
+            except (ValueError, UnicodeDecodeError):
+                sys.stdout.buffer.write(response.body)
+        return 0
+    except ScholarError as error:
+        report = error_info(error)
+        print(json.dumps(report, ensure_ascii=False) if args.json_errors else report["message"], file=sys.stderr)
+        if not args.json_errors:
+            print_error_details(report, sys.stderr)
+        return 1
+    except (ValueError, OSError) as error:
+        message = "配置、输入或文件错误：" + str(error)
+        if args.command == "doctor" and args.json:
+            print(json.dumps({"ok": False, "message": message}, ensure_ascii=False))
+        else:
+            print(json.dumps({"message": message}, ensure_ascii=False) if args.json_errors else message, file=sys.stderr)
+        return 2
+    except (EOFError, KeyboardInterrupt):
+        print("操作已取消。", file=sys.stderr)
+        return 2
+
+
+if __name__ == "__main__":
+    sys.exit(main())

linxsci/scripts/scholar_client.py

@@ -0,0 +1,211 @@
+"""Scholar OpenAPI v2 client; Python standard library only."""
+import json
+import math
+import os
+import re
+import uuid
+from dataclasses import dataclass
+from pathlib import Path
+from urllib.error import HTTPError, URLError
+from urllib.parse import quote, urlencode, urlsplit
+from urllib.request import Request, build_opener, HTTPRedirectHandler
+
+if __package__:
+    from .scholar_config import resolve_settings
+else:
+    from scholar_config import resolve_settings
+
+
+class ScholarError(Exception):
+    def __init__(self, message, status=None, body=None, headers=None):
+        super().__init__(message)
+        self.status, self.body, self.headers = status, body, headers or {}
+
+    @property
+    def error_code(self):
+        if isinstance(self.body, dict) and isinstance(self.body.get("error"), dict):
+            code = self.body["error"].get("code")
+            return code if type(code) in (str, int) else None
+        return None
+
+    @property
+    def request_id(self):
+        headers = {k.lower(): v for k, v in self.headers.items()}
+        if headers.get("x-request-id"):
+            return headers["x-request-id"]
+        if isinstance(self.body, dict) and isinstance(self.body.get("error"), dict):
+            value = self.body["error"].get("request_id")
+            return value if isinstance(value, str) else None
+        return None
+
+    @property
+    def framework_request_id(self):
+        if isinstance(self.body, dict) and isinstance(self.body.get("extra"), dict):
+            value = self.body["extra"].get("request-id")
+            return value if isinstance(value, str) else None
+        return None
+
+    @property
+    def execution_uncertain(self):
+        """The upstream returned, but member did not confirm finish; do not blindly retry."""
+        return self.error_code == -3905
+
+
+class NoRedirect(HTTPRedirectHandler):
+    def redirect_request(self, req, fp, code, msg, headers, newurl):
+        return None  # Never forward credentials to another location.
+
+
+@dataclass
+class Response:
+    status: int
+    headers: dict
+    body: bytes
+
+    def json(self):
+        return json.loads(self.body)
+
+
+# The proxy document defines routes, but not upstream business schemas.
+ROUTES = [
+    ("GET", "/meta"), ("GET", "/usage"),
+    ("GET", "/health/live"), ("GET", "/health/ready"),
+    ("POST", "/papers/search"), ("POST", "/search/openalex"),
+    ("POST", "/search/semantic-scholar"), ("POST", "/search/google-scholar"),
+    ("POST", "/papers/resolve"), ("POST", "/papers:batchGet"),
+    ("POST", "/recommendations"), ("GET", "/recommendations/mobile-cards"),
+    ("POST", "/entities:resolve"), ("POST", "/pdf/parse"),
+    ("POST", "/pdf/parse/upload"), ("GET", "/pdf/parse/{task_id}"),
+    ("GET", "/pdf/parse/{task_id}/result"),
+]
+ROUTES += [("GET", "/papers/{paper_id}" + suffix) for suffix in
+           ("", "/content", "/toc", "/sections/{section_id}", "/figures",
+            "/assets/{asset_id}", "/references", "/citations", "/related",
+            "/graph", "/citation")]
+ROUTES += [("GET", "/" + kind + "/{" + ident + "}" + suffix)
+           for kind, ident in (("authors", "author_id"),
+                               ("institutions", "institution_id"), ("venues", "venue_id"))
+           for suffix in ("", "/papers")]
+
+
+def segment(value):
+    if not str(value) or str(value) in (".", ".."):
+        raise ValueError("Path identifiers must be nonempty and cannot be . or ..")
+    return quote(str(value), safe=":")
+
+
+def paper_segment(value):
+    if not re.fullmatch(r"(?:local|arxiv|openalex|s2|doi):.+", value):
+        raise ValueError("paper_id requires local:, arxiv:, openalex:, s2: or doi: prefix")
+    return segment(value)
+
+
+def paper_path(paper_id, resource=None, item_id=None):
+    path = "/papers/" + paper_segment(paper_id)
+    if resource:
+        if resource not in ("content", "toc", "sections", "figures", "assets", "references", "citations", "related", "graph", "citation"):
+            raise ValueError("Unknown paper resource")
+        path += "/" + resource
+        if resource in ("sections", "assets"):
+            path += "/" + segment(item_id if item_id is not None else "")
+        elif item_id is not None:
+            raise ValueError("item_id is only supported for sections or assets")
+    elif item_id is not None:
+        raise ValueError("item_id requires sections or assets")
+    return path
+
+
+def request_header(value, name):
+    if not isinstance(value, str) or not value or any(ord(c) < 32 or ord(c) > 126 for c in value):
+        raise ValueError(name + " must be a nonempty printable ASCII value")
+    return value
+
+
+class ScholarClient:
+    def __init__(self, base_url=None, api_key=None, timeout=60, *, framework_request_id=None):
+        base_url, api_key = resolve_settings(base_url, api_key)
+        url = urlsplit(base_url)
+        if url.scheme not in ("http", "https") or not url.netloc or url.username or url.password or url.query or url.fragment:
+            raise ValueError("SCHOLAR_BASE_URL must be an http(s) service root URL")
+        if url.path.endswith(("/openapi/v2", "/openapi/v1")):
+            raise ValueError("Base URL must not include /openapi/v2 or /openapi/v1")
+        if not api_key or any(c in api_key for c in "\r\n"):
+            raise ValueError("Set SCHOLAR_OPENAPI_KEY to a valid Scholar key")
+        if not math.isfinite(timeout) or timeout <= 0:
+            raise ValueError("timeout must be a positive finite number")
+        self.base_url, self.api_key, self.timeout = base_url, api_key, timeout
+        self.framework_request_id = (request_header(framework_request_id, "X-ANYTHINGRIGHT-REQ-ID")
+                                     if framework_request_id is not None else None)
+        self.opener = build_opener(NoRedirect())
+
+    def request(self, method, path, *, query=None, payload=None, file=None,
+                fields=None, mineru_key=None, request_id=None, framework_request_id=None):
+        method = method.upper()
+        if not any(method == m and re.fullmatch(re.sub(r"\{[^}]+\}", r"[^/]+", p), path)
+                   for m, p in ROUTES):
+            raise ValueError("Unsupported v2 route or HTTP method")
+        if any(x in path for x in ("?", "#")) or any(x in (".", "..") for x in path.split("/")):
+            raise ValueError("Invalid path; pass query separately and encode identifiers")
+        if method == "GET" and (payload is not None or file is not None):
+            raise ValueError("GET requests cannot carry a body")
+        if path == "/pdf/parse/upload" and file is None:
+            raise ValueError("PDF upload requires a file")
+        if file is not None and (path != "/pdf/parse/upload" or payload is not None):
+            raise ValueError("file is only supported for PDF upload without JSON")
+        if fields and file is None:
+            raise ValueError("Form fields require PDF upload")
+        if mineru_key and not path.startswith("/pdf/parse"):
+            raise ValueError("MinerU key is only supported on PDF routes")
+        headers = {"Authorization": "Bearer " + self.api_key,
+                   "X-Request-ID": request_header(request_id, "X-Request-ID") if request_id is not None else str(uuid.uuid4())}
+        framework_id = framework_request_id if framework_request_id is not None else self.framework_request_id
+        if framework_id is not None:
+            headers["X-ANYTHINGRIGHT-REQ-ID"] = request_header(framework_id, "X-ANYTHINGRIGHT-REQ-ID")
+        if mineru_key:
+            headers["X-MinerU-API-Key"] = mineru_key
+        body = None
+        if payload is not None:
+            body = json.dumps(payload, ensure_ascii=False).encode()
+            headers["Content-Type"] = "application/json"
+        if file is not None:
+            source = Path(file)
+            boundary = "scholar-" + uuid.uuid4().hex
+            chunks = []
+            for key, value in (fields or {}).items():
+                if any(c in key for c in '\r\n"'):
+                    raise ValueError("Invalid form field name")
+                chunks.append((f'--{boundary}\r\nContent-Disposition: form-data; name="{key}"\r\n\r\n{value}\r\n').encode())
+            filename = source.name.replace('"', '_').replace("\r", "_").replace("\n", "_")
+            chunks.append((f'--{boundary}\r\nContent-Disposition: form-data; name="file"; filename="{filename}"\r\nContent-Type: application/pdf\r\n\r\n').encode())
+            chunks += [source.read_bytes(), f"\r\n--{boundary}--\r\n".encode()]
+            body = b"".join(chunks)
+            headers["Content-Type"] = "multipart/form-data; boundary=" + boundary
+        url = self.base_url + "/openapi/v2" + path
+        if query:
+            url += "?" + urlencode(query, doseq=True)
+        try:
+            with self.opener.open(Request(url, data=body, headers=headers, method=method), timeout=self.timeout) as response:
+                return Response(response.status, dict(response.headers), response.read())
+        except HTTPError as error:
+            raw = error.read()
+            try:
+                detail = json.loads(raw)
+            except (ValueError, UnicodeDecodeError):
+                detail = raw.decode("utf-8", errors="replace")
+            raise ScholarError(f"Scholar HTTP {error.code}", error.code, detail, dict(error.headers)) from None
+        except (URLError, TimeoutError, OSError):
+            raise ScholarError("Scholar network request failed; check service URL and connectivity") from None
+
+    def search(self, query, **options):
+        return self.request("POST", "/papers/search", payload={**options, "query": query})
+
+    def paper(self, paper_id, resource=None, *, item_id=None, query=None):
+        return self.request("GET", paper_path(paper_id, resource, item_id), query=query)
+
+    def upload_pdf(self, file, *, fields=None, mineru_key=None):
+        return self.request("POST", "/pdf/parse/upload", file=file, fields=fields, mineru_key=mineru_key)
+
+    def pdf_task(self, task_id, *, result=False):
+        if task_id == "upload":
+            raise ValueError("task_id cannot be upload")
+        return self.request("GET", "/pdf/parse/" + segment(task_id) + ("/result" if result else ""))

linxsci/scripts/scholar_config.py

@@ -0,0 +1,111 @@
+"""Shared local configuration for CLI, SDK and installed Skill."""
+import json
+import os
+import tempfile
+from pathlib import Path
+from urllib.parse import urlsplit
+
+
+class ConfigError(ValueError):
+    pass
+
+
+def config_path():
+    override = os.environ.get("SCHOLAR_CONFIG_FILE")
+    if override:
+        return Path(override).expanduser()
+    if os.name == "nt":
+        root = Path(os.environ.get("LOCALAPPDATA", str(Path.home() / "AppData/Local")))
+    else:
+        root = Path.home() / ".config"
+    return root / "linxsci-scholar" / "config.json"
+
+
+def validate_url(value):
+    if not isinstance(value, str):
+        raise ConfigError("服务地址必须是文本。")
+    value = value.strip().rstrip("/")
+    try:
+        url = urlsplit(value)
+        port = url.port
+    except ValueError:
+        raise ConfigError("服务地址格式错误，请填写 http(s) 服务根地址。") from None
+    if (url.scheme not in ("http", "https") or not url.hostname or url.username is not None
+            or url.password is not None or url.query or url.fragment
+            or any(c.isspace() or ord(c) < 32 for c in value)):
+        raise ConfigError("服务地址必须是 http(s) 根地址，不能包含账号、查询参数或空白。")
+    if url.path.endswith(("/openapi/v2", "/openapi/v1")):
+        raise ConfigError("服务地址不应包含 /openapi/v2 或 /openapi/v1。")
+    return value
+
+
+def validate_key(value):
+    if not isinstance(value, str) or not value.strip() or any(c in value for c in "\r\n"):
+        raise ConfigError("API Key 不能为空或包含换行。请重新配置。")
+    return value.strip()
+
+
+def service_defaults():
+    try:
+        values = json.loads((Path(__file__).resolve().parents[1] / "service.json").read_text(encoding="utf-8"))
+        return {key: validate_url(values[key]) for key in ("base_url", "online_base_url")}
+    except (OSError, KeyError, TypeError, ValueError):
+        raise ConfigError("安装包的服务配置损坏，请重新安装。") from None
+
+
+def load_config():
+    path = config_path()
+    if not path.exists():
+        return {}
+    try:
+        values = json.loads(path.read_text(encoding="utf-8"))
+    except (OSError, ValueError):
+        raise ConfigError("无法读取本地配置，请运行 setup 重新配置。") from None
+    if not isinstance(values, dict):
+        raise ConfigError("本地配置格式错误，请运行 setup 重新配置。")
+    result = {}
+    if "base_url" in values:
+        result["base_url"] = validate_url(values["base_url"])
+    if "api_key" in values:
+        result["api_key"] = validate_key(values["api_key"])
+    return result
+
+
+def resolve_settings(base_url=None, api_key=None):
+    # Explicit arguments > environment > saved configuration > release defaults.
+    base_url = base_url or os.environ.get("SCHOLAR_BASE_URL")
+    api_key = api_key or os.environ.get("SCHOLAR_OPENAPI_KEY")
+    saved = load_config() if not (base_url and api_key) else {}
+    base_url = base_url or saved.get("base_url") or service_defaults()["base_url"]
+    api_key = api_key or saved.get("api_key")
+    if not api_key:
+        raise ConfigError("尚未配置 API Key。请运行 linxsci setup，或安装包内的 install.py。")
+    return validate_url(base_url), validate_key(api_key)
+
+
+def save_config(base_url, api_key):
+    values = {"base_url": validate_url(base_url), "api_key": validate_key(api_key)}
+    path = config_path()
+    path.parent.mkdir(mode=0o700, parents=True, exist_ok=True)
+    if path.is_symlink():
+        raise ConfigError("配置文件不能是符号链接，请选择普通配置文件。")
+    fd, temporary = tempfile.mkstemp(prefix=".config-", dir=path.parent)
+    try:
+        if os.name != "nt":
+            os.fchmod(fd, 0o600)
+        with os.fdopen(fd, "w", encoding="utf-8") as stream:
+            json.dump(values, stream, ensure_ascii=False, indent=2)
+            stream.write("\n")
+        os.replace(temporary, path)
+    finally:
+        if os.path.exists(temporary):
+            os.unlink(temporary)
+    return path
+
+
+def clear_config():
+    path = config_path()
+    if path.is_symlink():
+        raise ConfigError("配置文件不能是符号链接。")
+    path.unlink(missing_ok=True)
+    return path

linxsci/scripts/scholar_install.py

@@ -0,0 +1,62 @@
+"""Install the bundled Skill without pip or network access."""
+import json
+import os
+import shutil
+import tempfile
+import uuid
+from pathlib import Path
+
+SKILL_NAME = "linxsci-skills"
+LEGACY_SKILL_NAME = "linxsci-scholar"
+MARKER = ".linxsci-install.json"
+
+
+def default_skills_dir():
+    return Path.home() / ".agents" / "skills"
+
+
+def install_skill(skills_dir=None, update=False):
+    source = Path(__file__).resolve().parents[1]
+    parent = Path(skills_dir).expanduser() if skills_dir else default_skills_dir()
+    destination = parent / SKILL_NAME
+    legacy = parent / LEGACY_SKILL_NAME
+    if destination.is_symlink():
+        raise ValueError("目标 Skill 是符号链接，请选择其他安装目录。")
+    if legacy.is_symlink():
+        raise ValueError("旧 Skill 是符号链接，请使用原安装工具管理它，或选择其他目录。")
+    if destination.exists() and legacy.exists():
+        raise ValueError("检测到新旧两个 Skill 目录，请先将不再使用的副本备份到助手扫描目录之外。")
+    existing = destination if destination.exists() else legacy
+    if existing.exists():
+        if not update:
+            raise ValueError("Skill 已存在。更新或迁移本工具安装的版本请使用 --update；自定义安装请先备份。")
+        marker = existing / MARKER
+        try:
+            installed = json.loads(marker.read_text(encoding="utf-8"))
+        except (OSError, ValueError):
+            raise ValueError("目标目录不是本安装工具管理的 Skill，请先备份或选择其他目录。") from None
+        if not isinstance(installed, dict) or installed.get("name") != existing.name:
+            raise ValueError("安装标记不匹配，请选择其他目录。")
+    parent.mkdir(parents=True, exist_ok=True)
+    staging = Path(tempfile.mkdtemp(prefix=".linxsci-stage-", dir=parent))
+    backup = None
+    try:
+        shutil.copytree(source, staging, dirs_exist_ok=True,
+                        ignore=shutil.ignore_patterns("__pycache__", "*.pyc", MARKER))
+        (staging / MARKER).write_text(json.dumps({"name": SKILL_NAME, "version": "0.3.0"}), encoding="utf-8")
+        if existing.exists():
+            backup_root = parent.parent / "linxsci-skill-backups"
+            backup_root.mkdir(parents=True, exist_ok=True)
+            backup = backup_root / (existing.name + ".backup-" + uuid.uuid4().hex[:8])
+            os.replace(existing, backup)
+        try:
+            os.replace(staging, destination)
+        except OSError:
+            if backup:
+                os.replace(backup, existing)
+                backup = None
+            raise
+    finally:
+        if staging.exists():
+            shutil.rmtree(staging)
+    return destination, backup

linxsci/service.json

@@ -0,0 +1,4 @@
+{
+  "base_url": "https://linxsci.com",
+  "online_base_url": "https://linxsci.com"
+}

linxsci_sdk-0.3.0.dist-info/METADATA

@@ -0,0 +1,218 @@
+Metadata-Version: 2.4
+Name: linxsci-sdk
+Version: 0.3.0
+Summary: Scholar OpenAPI v2 CLI and Python client
+Project-URL: Homepage, https://linxsci.com
+Project-URL: Repository, https://github.com/LinxSci/linxsci-skills
+Project-URL: Documentation, https://github.com/LinxSci/linxsci-skills/blob/main/README.md
+Project-URL: Issues, https://github.com/LinxSci/linxsci-skills/issues
+Requires-Python: >=3.9
+Description-Content-Type: text/markdown
+
+# LinxSci SDK、CLI 与 Skills
+
+让 AI 助手帮你搜索学术论文、阅读相关章节、查询引用，并解析你指定的 PDF。
+
+你需要一个已有的 Scholar API Key，以及能够执行本地 Python 脚本的 AI 助手。运行环境需要 **Python 3.9+**；本工具不需要额外 Python 运行依赖。
+
+## 命令和 Skill 如何命名
+
+| 层级 | 当前名称或用法 |
+| --- | --- |
+| PyPI 安装包名 | `linxsci-sdk` |
+| 终端命令名 | `linxsci`，例如 `linxsci search "graph neural networks"` |
+| Python 导入名 | `linxsci`，例如 `from linxsci import ScholarClient` |
+| AI Skill 名称 | `linxsci-skills`，在助手中使用 `$linxsci-skills` |
+
+当前论文相关动作直接使用 `linxsci <动作>`，例如 `linxsci setup`、`linxsci search`、`linxsci paper`。单独执行 `linxsci` 显示帮助。未来新增能力可注册独立命令组，例如 `linxsci patents search`；这是命名示例，当前只提供 Scholar API 能力。
+
+本文统一使用表中的新名称。已有 Key 配置和 `SCHOLAR_*` 环境变量继续复用；安装过旧名称包的开发者先按 [名称迁移说明](docs/DEVELOPMENT.md#14-从旧名称迁移) 更新，避免两个包共用同一终端入口。新增能力的开发步骤见 [开发者指南](docs/DEVELOPMENT.md#91-新增其他-skill-的命名与入口)。
+
+## 对外发布路线
+
+通过 **PyPI 发布 CLI / SDK，通过官方 GitHub 仓库维护和分发 Skill**。源码已上传至 [LinxSci/linxsci-skills](https://github.com/LinxSci/linxsci-skills)，PyPI 首次发布仍在准备中。以下包名安装命令仅在 PyPI 发布成功后适用；发布前可使用本地 wheel、ZIP 或源码安装。
+
+CLI 的推荐安装与使用方式：
+
+```bash
+uv tool install linxsci-sdk
+linxsci setup
+linxsci search "graph neural networks"
+```
+
+升级使用 `uv tool upgrade linxsci-sdk`；找不到命令时按 [uv 官方工具指南](https://docs.astral.sh/uv/guides/tools/) 使用 `uv tool update-shell`，然后重新打开终端。SDK 用户应在自己的 Python 项目环境中执行 `python -m pip install linxsci-sdk`；`uv tool install` 的隔离环境不会把 SDK 安装到当前 Python 项目。
+
+Skill 官方仓库为 [LinxSci/linxsci-skills](https://github.com/LinxSci/linxsci-skills)，可使用支持 GitHub Skill 的安装器：
+
+```bash
+npx skills add https://github.com/LinxSci/linxsci-skills --skill linxsci-skills
+```
+
+该方式需要 Node.js / npx，按提示选择目标助手和安装范围。已安装本 CLI 的用户也可以运行 `linxsci install-skill` 安装随包携带的完整 Skill。安装后按 [普通用户指南](docs/USER_GUIDE.md) 配置 Key。官网接入步骤见 [官网接入说明](docs/WEBSITE_PUBLISHING.md) 与 [发布指南](docs/RELEASING.md)。
+
+## 普通用户：安装、配置、提问
+
+1. 下载发布方提供的 `linxsci-skills-0.3.0.zip`，解压。
+2. macOS 双击 `Install.command`；Windows 双击 `Install.bat`。也可以在解压目录运行 `python3 install.py`（Windows 用 `py -3 install.py`）。
+3. 在向导中确认服务地址，输入你的 API Key。输入时 Key 不会显示。向导保存配置并检查连接。
+4. 在助手中输入：
+
+> 使用 $linxsci-skills 搜索图神经网络相关论文，阅读方法章节，比较主要方法并附上来源。
+
+默认使用正式服务 **https://linxsci.com**，无需在用户电脑部署 Scholar。已有本地配置或环境变量优先于默认值，升级不会自动替换用户保存的测试地址。切换正式服务可运行 `linxsci setup --online`；ZIP 用户在解压目录运行 `python3 skills/linxsci-skills/scripts/cli.py setup --online`。测试环境配置见 [测试指南](docs/TESTING.md)。
+
+安装器默认将 Skill 放到 `~/.agents/skills/linxsci-skills`，见 [官方本地 Skill 说明](https://learn.chatgpt.com/docs/build-skills)。客户端未发现 Skill 时重启助手；其他加载位置可通过 `--skills-dir` 指定。旧版客户端使用 `~/.codex/skills` 时，也可显式指定该目录。
+
+ZIP 安装后即可在助手中使用 Skill；安装器不注册终端的 `linxsci` 命令。需要该命令时，按下面的 wheel 或源码安装流程操作。完整操作步骤、更新和故障处理见 [普通用户指南](docs/USER_GUIDE.md)。本项目不包含 AI 助手或 Scholar 服务器，也不负责注册账号或发放 Key。
+
+## 已安装 CLI 的用户
+
+当前发布文件可本地安装；尚未上传到 PyPI。安装 wheel 后执行：
+
+```bash
+linxsci install-skill
+linxsci setup --base-url https://linxsci.com
+linxsci search 'graph neural networks'
+```
+
+`linxsci setup` 一次保存配置，后续 CLI、SDK 和本地 Skill 共用。不需要每次 export 环境变量。`linxsci config` 查看配置状态，不显示 Key；`linxsci config --clear` 清除保存的地址和 Key。更新包后运行 `linxsci install-skill --update` 更新助手使用的脚本，旧 Skill 保留备份。
+
+逐个接口的完整命令、请求文件、ID 编码及 PDF 上传方式见 [全部 34 个接口的 CLI 使用指南](docs/CLI_GUIDE.md)。
+
+## 从本地源码开始测试
+
+在项目根目录执行。首次创建环境并安装开发版；已有 `.venv` 时可跳过创建：
+
+```bash
+python3 -m venv .venv
+source .venv/bin/activate
+python3 -m pip install --upgrade pip setuptools wheel
+python3 -m pip install -e .
+
+linxsci --version
+linxsci setup --base-url http://101.126.93.213:28888
+```
+
+Windows 激活命令为 `.venv\Scripts\activate`。统一使用同一个虚拟环境，不要混用 `.venv` 和 `.venv-1`。旧 pip 可能提示找不到 setup.py/setup.cfg，先执行上述升级命令；指定解释器安装时使用 `.venv/bin/python -m pip install -e .`，不要写成 `python -m python3 -m pip ...`。
+
+从旧名称的开发版本更新时，先按 [名称迁移说明](docs/DEVELOPMENT.md#14-从旧名称迁移) 卸载旧包，再安装当前源码。用 `linxsci --version` 和 `linxsci --help` 确认入口。已有 Key 无需重新输入；`linxsci install-skill --update` 会将本工具管理的旧 Skill 迁移到新目录并备份。
+
+按向导输入已有 API Key，输入时不会显示。`setup` 会检查一次连接，成功后即可检索；之后需要单独检查连接时运行 `linxsci doctor --json`，确认 `ok` 为 true 且 `base_url` 是测试服务地址。检查连接也会实际调用接口，无需反复执行。
+
+## 论文检索和阅读示例
+
+以下命令在已经激活虚拟环境、完成 Key 配置后执行。CLI 会输出服务返回的数据，整理和比较论文可以交给安装了 Skill 的助手。
+
+### 1. 按英文或中文主题检索
+
+```bash
+linxsci search "graph neural networks"
+linxsci search "大语言模型智能体"
+```
+
+将引号中的文字替换为自己的研究主题。检查返回论文的标题、摘要和主题是否相关，记录实际返回的论文 ID；未检索到结果时不应编造论文。
+
+### 2. 保存搜索结果
+
+```bash
+linxsci --output search.json search "graph neural networks"
+```
+
+响应原始内容保存到当前目录的 `search.json`，可用编辑器打开核查。`--output` 是全局选项，放在 `linxsci` 之后、`search` 或 `paper` 等具体动作之前。
+
+### 3. 查看论文详情、目录和相关章节
+
+先从搜索响应选择一篇论文，再从其目录选择章节。下列中文占位参数必须替换为真实返回值后执行：
+
+```bash
+linxsci paper "实际论文ID"
+linxsci paper "实际论文ID" --resource toc
+linxsci paper "实际论文ID" --resource sections --item-id "实际章节ID"
+```
+
+论文 ID 保留 `local:`、`arxiv:`、`openalex:`、`s2:` 或 `doi:` 来源前缀，不要用论文标题代替 ID。便捷命令接收未编码的 ID，并负责 URL 编码；章节 ID 必须来自接口响应，不能根据章节名称猜测。
+
+测试通过的标准是：详情对应所选论文，目录能定位真实章节，读取的章节内容与所选 ID 一致。不要仅凭接口未报错就判断内容正确。
+
+## 在助手中测试 Skill
+
+源码安装只提供 CLI/SDK。需要通过 `$linxsci-skills` 使用时，再安装 Skill；首次执行：
+
+```bash
+linxsci install-skill
+```
+
+已由本工具安装过，或修改源码后要同步到安装副本，执行：
+
+```bash
+linxsci install-skill --update
+```
+
+在支持本地 Skill 和脚本执行的助手中新建对话，分别尝试：
+
+**检索与筛选**
+
+> 使用 $linxsci-skills 检索图神经网络相关论文，选择最多三篇最相关的，说明相关性，并附实际返回的论文 ID 和来源。结果不足三篇时请如实说明。
+
+**按章节阅读**
+
+> 使用 $linxsci-skills 阅读论文“实际论文ID”，先查看目录，再读取方法相关章节，解释主要方法，并标明章节依据。
+
+**比较两篇论文**
+
+> 使用 $linxsci-skills 比较论文“实际论文ID一”和“实际论文ID二”的方法和实验结论，逐项列出来源。未找到证据的数据请明确说明，不要补写。
+
+将提示中的论文 ID 替换为实际检索结果。检查助手是否真正调用服务、引用是否能对应响应、数值是否有章节证据，以及是否存在重复检索或无目的读取全文。
+
+开发时也可在新对话中直接指定当前仓库 `skills/linxsci-skills/SKILL.md` 的绝对路径，要求助手读取该文件并执行同目录下的脚本，从而直接测试当前源码。复制安装的 Skill 不会随源码自动更新，修改后要先同步，避免误测旧版本。
+
+## 测试样例与验收重点
+
+| 测试样例 | 验收重点 |
+| --- | --- |
+| 英文、中文关键词检索 | 执行真实搜索，返回相关论文；空结果如实说明 |
+| 保存搜索结果 | `search.json` 存在，保留服务原始响应 |
+| 论文详情与目录 | 使用真实且带来源前缀的 ID，内容与论文对应 |
+| 读取指定章节 | 使用目录返回的实际章节 ID，证据能定位到正文 |
+| 助手筛选和比较 | 有真实调用记录，论文来源和结论可核查，不编造数值 |
+
+本地修改可直接连接测试环境验证，无需每次先 push Git 或重新打包。调优前后固定提示词和模型设置，记录结果准确性、调用次数、耗时以及需要人工纠正的地方。完整的 8 个验收场景、故障处理及记录模板见 [测试环境验收与 Skill 调优](docs/TESTING.md)。
+
+## 能力与范围
+
+已适配新版数字框架错误码、请求追踪和计费异常诊断。覆盖接口文档中的 34 条路由：服务信息和健康、论文搜索和标识解析、详情/内容/目录/章节/图表资源/引用、推荐、作者/机构/期刊、PDF 解析任务。全部 34 个接口均提供便捷命令，无需填写 HTTP 方法或接口路径；`request` 保留作通用调试入口。
+
+| 接口分类 | 数量 | 调用入口 |
+| --- | --- | --- |
+| 服务信息与健康检查 | 4 | `meta`、`usage`、`health live/ready` |
+| 论文搜索与解析 | 6 | `search`、`search-openalex`、`search-semantic-scholar`、`search-google-scholar`、`resolve`、`batch-get` |
+| 论文详情与引用 | 11 | `paper`，搭配 `--resource` 和 `--item-id` |
+| 论文推荐 | 2 | `recommend`、`mobile-cards` |
+| 作者、机构与期刊 | 7 | `author`、`institution`、`venue`（可加 `--papers`）、`resolve-entities` |
+| PDF 解析 | 4 | `parse-pdf`、`upload`、`task`（结果加 `--result`） |
+
+只需调用指定接口时，可以直接使用便捷命令。例如：
+
+```bash
+linxsci mobile-cards
+linxsci search-openalex "large language models"
+```
+
+四个搜索命令都直接接收检索词，可通过 `--body @文件.json` 添加契约中定义的其他参数。其他 JSON 请求文件需先按实际 Agent API 契约准备。便捷命令自动选择接口方法和路径；JSON 请求可通过 `--body @文件路径` 传入请求。PDF 上传为 multipart，使用 `linxsci upload /实际路径/paper.pdf`。在助手中也可直接提出“使用 $linxsci-skills 调用指定接口”，并提供接口路径及必要参数。
+
+研究比较和总结由助手根据实际读取的内容完成。目前接口文档未定义多数 POST 的业务字段、分页和 PDF 状态模型；这些高级接口应按部署版本的上游契约使用，不能假定空 JSON 有效。所有路由可调用不代表每条接口都已有专用表单或经过真实生产验证。
+
+## 开发与发布
+
+- [SDK 开发者指南：安装、配置、方法签名与全部 34 个接口](docs/DEVELOPMENT.md)
+- [CLI 使用指南：全部 34 个接口逐一调用](docs/CLI_GUIDE.md)
+- [测试环境验收与 Skill 调优](docs/TESTING.md)
+- [发布指南：构建、验证与分发](docs/RELEASING.md)
+- [官网接入说明：下载入口、三类文档与发布文件](docs/WEBSITE_PUBLISHING.md)
+- [Skill 指令](skills/linxsci-skills/SKILL.md)
+- [原始接口文档](Scholar-OpenAPI-v2-使用文档.md)
+
+```bash
+python3 -m unittest discover -s tests -v
+python3 tools/build_release.py --bundle-only
+```

linxsci_sdk-0.3.0.dist-info/RECORD

@@ -0,0 +1,19 @@
+scholar.py,sha256=CCetGJAtlmjHIpIuNCvNBwDvx8jWe_8vKwMVxD07SKI,159
+scholar_client.py,sha256=C4hem7vZFFO2BujxEorpbAMLJORjBbsU2DDMGI_0ONQ,136
+linxsci/SKILL.md,sha256=9QxaHGK4JEks92E-H_6co2haRkDANcsEgv1WkDduEAg,8274
+linxsci/__init__.py,sha256=WfeJ1Bn90kQxP5W_QlbjMIa7EWClVES-IZLNGMvtOFs,211
+linxsci/service.json,sha256=DiTX14q2fqvTcM7I2d1q8beSlQn8KFm2nlHqfB-i4uI,84
+linxsci/agents/openai.yaml,sha256=YaHCHax3_Oozjb1sA52AwkW0RCBtt3HH12JzxmNOYes,300
+linxsci/references/api.md,sha256=bzmsRnOdKpwMr_2m5biT7UUgijVU-gS5eRa8Lj-l4TQ,8168
+linxsci/references/cli.md,sha256=FMzN-1qpEUWD0AnqgkqzpZQAWog8rKzvfJfIqF_Gyuo,3515
+linxsci/scripts/__init__.py,sha256=eqGdpTajCBo_D5l4fypYmUg-qgUypo0w1v5apB52o8Q,56
+linxsci/scripts/cli.py,sha256=hqKZu6SRVYqWwqc5Et6MDP9EaaJqDoT63cLM7E6lyaY,1272
+linxsci/scripts/scholar.py,sha256=1ecmWa9t6lvOp3q1HPF-Z9Bug3QUz2dWwqMy22VVHQI,16684
+linxsci/scripts/scholar_client.py,sha256=s0lrEFqLEQ3BiXCShUiprmi8aXPX6-bfzs36040ATCc,10145
+linxsci/scripts/scholar_config.py,sha256=5ULS2uEG703IH17ySZ-IQ_UheT0hgak_t3D7RGhj0rE,4247
+linxsci/scripts/scholar_install.py,sha256=a4z0FJWpdKqdD_CvI-a_rUfyrI_xDfik4b-o_LDQmXs,2741
+linxsci_sdk-0.3.0.dist-info/METADATA,sha256=ONuoRVvxxaMTRcT8gZDdED3OmxdMIHoxt6g3TKOzIlw,13454
+linxsci_sdk-0.3.0.dist-info/WHEEL,sha256=aeYiig01lYGDzBgS8HxWXOg3uV61G9ijOsup-k9o1sk,91
+linxsci_sdk-0.3.0.dist-info/entry_points.txt,sha256=mFFFi_qpG3p6U_ohN1FNBNjwAPEL6Ua12dX5TWE-WAU,53
+linxsci_sdk-0.3.0.dist-info/top_level.txt,sha256=ZpgyGVDAJHMUuY6mLdTBDapgwOuq1q40sgiJ8nCVv94,31
+linxsci_sdk-0.3.0.dist-info/RECORD,,

linxsci_sdk-0.3.0.dist-info/WHEEL

@@ -0,0 +1,5 @@
+Wheel-Version: 1.0
+Generator: setuptools (82.0.1)
+Root-Is-Purelib: true
+Tag: py3-none-any
+

linxsci_sdk-0.3.0.dist-info/entry_points.txt

@@ -0,0 +1,2 @@
+[console_scripts]
+linxsci = linxsci.scripts.cli:main

linxsci_sdk-0.3.0.dist-info/top_level.txt

@@ -0,0 +1,3 @@
+linxsci
+scholar
+scholar_client

scholar.py

@@ -0,0 +1,5 @@
+"""Compatibility entry point; prefer the linxsci package."""
+from linxsci.scripts.scholar import main
+
+if __name__ == "__main__":
+    raise SystemExit(main())

scholar_client.py

@@ -0,0 +1,2 @@
+"""Compatibility imports for SDK 0.1 users."""
+from linxsci.scripts.scholar_client import Response, ScholarClient, ScholarError, ROUTES