PDF 表单填写 pdf-form-filler：查看字段、按字段名批量填写（文本框/复选/下拉）；AI 建议每个字段填什么（读 PDF 表单 + 用户上下文 + 置信度）。适合报名表/申请表/入职表/审批表/体检表批量填写。
---
name: pdf-form-filler
description: PDF 表单填写 pdf-form-filler：查看表单字段、按字段名批量填写（文本框/复选/下拉/签名字段）；AI 建议每个字段填什么（读 PDF 表单 + 用户上下文 + 置信度）。适合报名表/申请表/入职表/审批表/体检表/调查问卷批量填写。本地执行、原文件不动。
---
本 skill 的真实能力依赖平台后端工具。在网页 / chat 端点下，这些工具可能不可用：
此时**请勿轻信**，请改用 **agent / CLI 路径**运行本 skill 以获取真实结果。任何路径下都**严禁谎称「已调用 / 已搜索完成」而实际未执行**。
查看 PDF 表单有哪些字段，并按 JSON 数据批量填写，输出填写后的副本。适用于报名表、申请表、审批表、入职表、体检表等。可选 AI 建议每个字段的最佳填值（基于 PDF 表单内容 + 用户给出的上下文）。
**场景 1：HR 批量填入职表** —— 新员工入职表 PDF 模板，每个员工填一份。用 `--data` 一次性传 20 个员工的信息，秒出 20 份已填好的 PDF。
**场景 2：活动报名表不会填** —— 拿到一份复杂的活动报名表 PDF，不知道"紧急联系人电话"应该填什么，用 `suggest` 让 AI 看上下文 + 表单字段给你建议。
**场景 3：审批表结构化批量填写** —— 财务审批表字段固定（申请人/部门/金额/事由/日期），用脚本批量填入并归档。
| 角色 | 典型用途 |
|------|----------|
| HR / 人事 | 入职表、绩效表、考勤表批量填写 |
| 学生 / 教师 | 报名表、申请表、调查问卷填写 |
| 财务 / 会计 | 报销单、审批表、转账单填写 |
| 行政 / 文员 | 各类审批表、登记表批量处理 |
| 活动组织方 | 报名表、活动签到表 |
| 个人用户 | 各类需要填写的 PDF 表单 |
# 第一步：查看字段
python scripts/pdf_form.py fields --input 报名表.pdf
# 返回 [{"name": "name", "type": "text"}, {"name": "phone", "type": "text"}, ...]
# 第二步：填写
python scripts/pdf_form.py fill \
--input 报名表.pdf \
--data '{"name": "张三", "phone": "13800000000", "agree": true}' \
--output 报名表_已填.pdf
# 返回 {"ok": true, "filled_fields": 3, "output": "报名表_已填.pdf"}
# 第三步（可选）：AI 建议每个字段填什么
python scripts/pdf_form.py suggest \
--input 报名表.pdf \
--context "我是张三，30 岁，邮箱 zhang@example.com，电话 13800000000"
# AI 返回每个字段的建议值 + 置信度| 对比项 | 手动填 PDF | pdf-form-filler |
|--------|-----------|-----------------|
| 批量填 50 份 | 50 分钟 | 1 分钟 |
| 字段名记错 | 静默漏填 | 报错列出现有字段 |
| AI 不会填的字段 | 自己琢磨 | `suggest` 给建议 + 置信度 |
| 复选框勾错 | 容易漏勾 | JSON `true/false` 自动勾 |
| 成本 | 免（费时间）| ¥0.10/次起 |
用户要求"填写 PDF 表单 / PDF 表单自动填 / 帮我填这个 PDF 表 / 批量填表 / 帮我看看这个表该怎么填"时触发。
用户要求"填写 PDF 表单 / PDF 表单自动填 / 帮我填这个 PDF 表 / 批量填表 / 帮我看看这个表该怎么填"时触发。
pip install pypdf pymupdf
# AI 建议填值（suggest）：依赖 AIMS_API_KEYpython scripts/pdf_form.py fields --input 报名表.pdf返回字段名、类型（文本/按钮/下拉/签名）、当前值。**必须先看字段名再填**，字段名写错会报错而不是静默跳过。
python scripts/pdf_form.py fill \
--input 报名表.pdf \
--data '{"name": "张三", "phone": "13800000000"}' \
--output 报名表_已填.pdfpython scripts/pdf_form.py suggest \
--input 报名表.pdf \
--context "我是张三，30 岁，邮箱 zhang@example.com，电话 13800000000"AI 读 PDF 表单结构 + 用户上下文 → 返回每个字段的建议值和置信度（0.0-1.0）。用户审过后把 `suggestions` 转成 `--data` JSON 即可一键填表。依赖 `AIMS_API_KEY`。- 输出为新文件，原文件不动
1. **先 fields 后 fill**：字段名对不上直接报错（列出不存在字段），不猜、不静默漏填
2. 加密 PDF 需 `--password`（仅限本人有权处理的文档）
3. 无表单的 PDF 报错提示（/AcroForm 不存在）
4. 输出 JSON：`{"ok": true, "filled_fields": N, "output": "..."}`
| 情况 | 处理 |
|---|---|
| 字段不存在 | 报错并列出现有字段名 |
| PDF 无表单 | 报错提示该文件不是表单 |
| 加密无密码 | 提示提供密码（先确认归属） |
<!-- ===== 以下为内嵌脚本代码（agent 安装时按需落盘为 scripts/<name> 并 chmod +x） ===== -->
#!/usr/bin/env python3
# -*- coding: utf-8 -*-
"""PDF 表单：查看字段 / 填写表单字段 / 导出已填写副本 / AI 建议字段值。
用法示例：
python pdf_form.py fields --input 表单.pdf
python pdf_form.py fill --input 表单.pdf --data '{"name": "张三", "age": "30"}' --output 已填.pdf
python pdf_form.py suggest --input 表单.pdf --context "我是张三，30 岁，邮箱 zhang@example.com" # AI 建议每个字段值
依赖：pip install pypdf pymupdf
说明：填写后保留原始外观；若需锁定不可编辑，需另加 flatten（LibreOffice 或 pdftk）。
AI 增强（suggest）：依赖 AIMS_API_KEY
"""
import argparse
import json
import sys
from pathlib import Path
try:
from pypdf import PdfReader, PdfWriter
from pypdf.generic import NameObject, TextStringObject, BooleanObject
except ImportError: # pragma: no cover
sys.stderr.write("缺少依赖 pypdf，请先执行: pip install pypdf\n")
sys.exit(2)
# 让脚本可作为 pdf-form-filler 独立 skill 运行
_HERE = Path(__file__).resolve().parent
_ROOT = _HERE.parent.parent
# _lib 查找（2026-09-22 修复）：优先包内 _lib/（发布包已随附），
# 退回开发布局 office-skills/_lib —— 否则装到用户侧会 ModuleNotFoundError。
for _lib_cand in (Path(__file__).resolve().parent.parent / "_lib",
Path(__file__).resolve().parent.parent.parent / "_lib"):
if _lib_cand.is_dir():
sys.path.insert(0, str(_lib_cand))
break
else:
raise RuntimeError(
"找不到 _lib/（需要 aims_functional_api.py）。"
"发布包应自带 _lib/；开发环境下请确认 office-skills/_lib 存在。"
)
try:
from aims_chat import chat_text_json, chat_pdf_page
_AIMS_OK = True
except Exception: # pragma: no cover
_AIMS_OK = False
def cmd_fields(args) -> dict:
reader = PdfReader(args.input)
if reader.is_encrypted and args.password:
reader.decrypt(args.password)
fields = reader.get_fields() or {}
out = []
for name, f in fields.items():
ft = f.get("/FT", "unknown")
ft_map = {"/Tx": "文本", "/Btn": "按钮/复选", "/Ch": "下拉/列表", "/Sig": "签名"}
out.append({
"name": name,
"type": ft_map.get(str(ft), str(ft)),
"value": f.get("/V", ""),
"default": f.get("/DV", ""),
})
return {"ok": True, "file": args.input, "fields": out, "count": len(out)}
def _list_fields_for_suggest(args):
reader = PdfReader(args.input)
if reader.is_encrypted and args.password:
reader.decrypt(args.password)
fields = reader.get_fields() or {}
out = []
for name, f in fields.items():
ft = f.get("/FT", "unknown")
out.append({"name": name, "type": str(ft), "label": f.get("/TU") or ""})
return out
def _pdf_summary(args):
"""读 PDF 文本层 + 必要时 OCR 第一页，让 AI 知道表单主题。"""
reader = PdfReader(args.input)
if reader.is_encrypted and args.password:
reader.decrypt(args.password)
txt = ""
for p in reader.pages[:3]:
try:
t = p.extract_text() or ""
if t.strip():
txt += t + "\n"
except Exception:
pass
if not txt.strip() and _AIMS_OK:
try:
txt = chat_pdf_page(args.input, 0, "请输出这张 PDF 表单的全部文字内容（字段标题、说明等）。",
zoom=2.0, api_key=args.api_key)
except Exception:
txt = ""
return txt[:3000]
def cmd_suggest(args) -> dict:
"""AI 读 PDF 主题 + 字段清单 + 用户上下文 → 建议每个字段填什么。"""
if not _AIMS_OK:
raise RuntimeError("suggest 需要 AIMS helper")
fields = _list_fields_for_suggest(args)
if not fields:
raise ValueError("该 PDF 没有表单字段")
pdf_summary = _pdf_summary(args)
prompt = (
"你是一个 PDF 表单填写助手。下面是 PDF 表单的字段清单与少量上下文，"
"请根据用户提供的「个人/业务上下文」给出每个字段的最佳填写建议。\n"
"严格返回 JSON（不要解释、不要 Markdown 代码块），格式：\n"
"{\"suggestions\": [{\"name\": \"字段名\", \"value\": \"建议值\", \"confidence\": 0.0-1.0}, ...]}\n"
"置信度低于 0.5 的字段请跳过；日期格式按字段标签提示判断。\n"
f"--- PDF 摘要 ---\n{pdf_summary or '(无文本层)'}\n"
f"--- 字段清单 ---\n{json.dumps(fields, ensure_ascii=False)}\n"
f"--- 用户上下文 ---\n{args.context or '(未提供)'}"
)
result = chat_text_json(prompt, api_key=args.api_key, max_tokens=3000)
sugg = result.get("suggestions", [])
return {
"ok": True,
"file": args.input,
"fields_total": len(fields),
"suggestions": sugg,
"count": len(sugg),
"note": "AI 建议，仅供参考；填写前请人工核对",
}
def cmd_fill(args) -> dict:
reader = PdfReader(args.input)
if reader.is_encrypted:
if not args.password:
raise ValueError("PDF 已加密，请提供 --password（仅限本人有权处理的文档）")
if not reader.decrypt(args.password):
raise ValueError("密码错误")
data = json.loads(args.data)
if not isinstance(data, dict):
raise ValueError("--data 应为 JSON 对象，如 {\"name\": \"张三\"}")
# 校验字段是否存在，避免静默漏填
fields = reader.get_fields() or {}
unknown = [k for k in data if k not in fields]
if unknown:
raise ValueError(f"以下字段不存在于表单: {unknown}；可用 fields 命令查看全部字段")
writer = PdfWriter()
writer.append(reader)
# 直接写字段 /V 值（兼容 reportlab / 各类生成器），并开启 NeedAppearances
acro = writer.root_object.get("/AcroForm")
if acro is None:
raise ValueError("该 PDF 没有表单（/AcroForm 不存在）；请用 fields 命令确认")
acro_fields = acro.get_object().get("/Fields") or []
if not acro_fields:
raise ValueError("该 PDF 表单为空（无字段）")
matched = 0
for field_ref in acro_fields:
field = field_ref.get_object()
name = field.get("/T")
if name and name in data:
field[NameObject("/V")] = TextStringObject(str(data[name]))
matched += 1
if matched == 0:
raise ValueError(f"字段名与数据不匹配，已匹配 0 个；可用 fields 命令查看字段名")
acro.get_object()[NameObject("/NeedAppearances")] = BooleanObject(True)
out = Path(args.output)
out.parent.mkdir(parents=True, exist_ok=True)
with out.open("wb") as f:
writer.write(f)
return {
"ok": True,
"output": str(out),
"filled_fields": matched,
"note": "已生成填写副本，原文件未改动；部分阅读器打开时自动刷新显示",
}
def build_parser() -> argparse.ArgumentParser:
ap = argparse.ArgumentParser(description="PDF 表单工具")
ap.add_argument("--password", default=None)
sub = ap.add_subparsers(dest="command", required=True)
p = sub.add_parser("fields", help="列出表单字段")
p.add_argument("--input", required=True)
p.set_defaults(func=cmd_fields)
p = sub.add_parser("fill", help="填写表单字段")
p.add_argument("--input", required=True)
p.add_argument("--data", required=True, help='JSON 对象 {"字段名": "值"}')
p.add_argument("--output", required=True)
p.set_defaults(func=cmd_fill)
p = sub.add_parser("suggest", help="AI 建议每个字段的填值（依赖 AIMS_API_KEY）")
p.add_argument("--input", required=True)
p.add_argument("--context", default="", help="用户上下文，如「我是张三 30 岁 邮箱 zhang@example.com」")
p.add_argument("--api-key", default=None)
p.set_defaults(func=cmd_suggest)
return ap
def main():
args = build_parser().parse_args()
try:
result = args.func(args)
except Exception as e:
print(json.dumps({"ok": False, "error": str(e)}, ensure_ascii=False))
sys.exit(1)
print(json.dumps(result, ensure_ascii=False, indent=2))
if __name__ == "__main__":
main()<!-- ===== 以下为共享依赖 _lib（落盘为 _lib/<name>，与 scripts/ 同级上层） ===== -->
#!/usr/bin/env python3
# -*- coding: utf-8 -*-
"""AIMS 平台 AI 调用公共 helper（6 个 skill 复用）。
能力：
- chat_text(prompt, model="qwen-flash") 纯文本对话
- chat_vision(image_path_or_url, prompt, ...) 图片+文本多模态
- chat_pdf_pages(pdf_path, prompt, zoom=2.0) 扫描版 PDF OCR
- chat_with_usage(...) 返回文本+用量
环境：依赖 AIMS_API_KEY 环境变量或 --api-key
"""
import argparse
import base64
import json
import os
import sys
import time
import urllib.request
from pathlib import Path
AIMS_URL = "https://aimsgateway.cn/mcp/"
TEXT_MODEL = "qwen-flash" # 通用文本（最便宜）
VISION_MODEL = "qwen-vl-ocr-latest" # 视觉/OCR
# ---------- 鉴权 & 协议 ----------
def _get_key(api_key=None):
key = api_key or os.environ.get("AIMS_API_KEY")
if not key:
raise RuntimeError(
"缺少 AIMS API Key：请设置环境变量 AIMS_API_KEY，或调用方传 --api-key"
)
return key
def _rpc(url, key, method, params, mid, tries=3, timeout=180):
body = json.dumps({"jsonrpc": "2.0", "id": mid, "method": method, "params": params}).encode()
headers = {"Content-Type": "application/json", "Authorization": f"Bearer {key}"}
last = None
for _ in range(tries):
try:
req = urllib.request.Request(url, data=body, method="POST", headers=headers)
with urllib.request.urlopen(req, timeout=timeout) as r:
return json.loads(r.read().decode())
except Exception as e: # noqa: BLE001
last = e
time.sleep(2)
raise RuntimeError(f"MCP 调用失败: {last}")
def _handshake(key):
_rpc(AIMS_URL, key, "initialize",
{"protocolVersion": "2025-03-26", "capabilities": {},
"clientInfo": {"name": "office-skills", "version": "1.0"}}, 1)
try:
_rpc(AIMS_URL, key, "notifications/initialized", {}, 2)
except Exception:
pass
# ---------- 图片编码 ----------
def _file_to_data_url(path):
p = Path(path)
if not p.exists():
raise FileNotFoundError(path)
b64 = base64.b64encode(p.read_bytes()).decode()
ext = p.suffix.lower()
mime = {
"png": "image/png", "jpg": "image/jpeg", "jpeg": "image/jpeg",
"gif": "image/gif", "webp": "image/webp", "bmp": "image/bmp",
}.get(ext, "image/png")
return f"data:{mime};base64,{b64}"
def _pdf_page_to_data_url(pdf_path, page_index=0, zoom=2.0):
try:
import fitz # PyMuPDF
except ImportError:
raise RuntimeError("PDF 多模态需要 PyMuPDF：pip install pymupdf")
doc = fitz.open(pdf_path)
if page_index < 0 or page_index >= doc.page_count:
raise IndexError(f"页码 {page_index} 越界，共 {doc.page_count} 页")
pix = doc[page_index].get_pixmap(matrix=fitz.Matrix(zoom, zoom))
raw = pix.tobytes("png")
b64 = base64.b64encode(raw).decode()
return f"data:image/png;base64,{b64}"
# ---------- 聊天封装 ----------
def _chat_call(key, model, content, max_tokens=4000, temperature=0, mid=7, no_rag=True):
"""调 aims.chat。
关键参数 `no_rag` 默认 True（2026-09-16 平台确认）：
- 平台默认给 chat 注入知识库（KB）内容，视觉模型/OCR 收到 RAG 文本会跑偏
- 加上 `no_rag: True` 后，模型纯粹根据 prompt + 图片回答
- 纯文本调用也建议加，避免被 KB 干扰
"""
arguments = {
"model": model,
"messages": [{"role": "user", "content": content}],
"max_tokens": max_tokens, "temperature": temperature,
"no_rag": no_rag,
}
resp = _rpc(AIMS_URL, key, "tools/call",
{"name": "aims.chat", "arguments": arguments}, mid)
txt = resp.get("result", {}).get("content", [{}])[0].get("text", "")
if not txt:
raise RuntimeError("平台返回为空: " + json.dumps(resp, ensure_ascii=False)[:300])
try:
obj = json.loads(txt)
return obj["choices"][0]["message"]["content"], obj.get("usage", {})
except Exception:
return txt, {}
def chat_text(prompt, model=None, max_tokens=4000, temperature=0, api_key=None, no_rag=True):
"""纯文本对话：返回文本。"""
key = _get_key(api_key)
_handshake(key)
model = model or TEXT_MODEL
text, _ = _chat_call(key, model, prompt, max_tokens, temperature, no_rag=no_rag)
return text.strip()
def chat_text_with_usage(prompt, model=None, max_tokens=4000, temperature=0, api_key=None, no_rag=True):
key = _get_key(api_key)
_handshake(key)
model = model or TEXT_MODEL
text, usage = _chat_call(key, model, prompt, max_tokens, temperature, no_rag=no_rag)
return text.strip(), usage
def chat_vision(image_input, prompt, model=None, max_tokens=4000, api_key=None, no_rag=True):
"""图片对话：image_input 可为本地路径或 data: URI。"""
key = _get_key(api_key)
_handshake(key)
model = model or VISION_MODEL
if image_input.startswith("data:"):
data_url = image_input
else:
data_url = _file_to_data_url(image_input)
content = [
{"type": "image_url", "image_url": {"url": data_url}},
{"type": "text", "text": prompt},
]
text, _ = _chat_call(key, model, content, max_tokens, 0, no_rag=no_rag)
return text.strip()
def chat_pdf_page(pdf_path, page_index, prompt, model=None, zoom=2.0, max_tokens=4000, api_key=None, no_rag=True):
"""扫描版 PDF 单页：先渲染成图，再视觉 OCR。"""
data_url = _pdf_page_to_data_url(pdf_path, page_index, zoom)
return chat_vision(data_url, prompt, model=model, max_tokens=max_tokens, api_key=api_key, no_rag=no_rag)
# ---------- JSON 输出辅助 ----------
def _strip_code_fence(s):
s = s.strip()
if s.startswith("```"):
lines = s.splitlines()
if lines and lines[0].startswith("```"):
lines = lines[1:]
if lines and lines[-1].strip().startswith("```"):
lines = lines[:-1]
s = "\n".join(lines)
return s.strip()
def chat_text_json(prompt, model=None, max_tokens=4000, api_key=None, no_rag=True):
"""纯文本对话 → 强制 JSON 输出（解析失败抛错）。"""
text = chat_text(prompt, model=model, max_tokens=max_tokens, api_key=api_key, no_rag=no_rag)
return json.loads(_strip_code_fence(text))
if __name__ == "__main__":
ap = argparse.ArgumentParser(description="AIMS 平台 AI 调用 helper 自检")
ap.add_argument("--api-key", default=None)
ap.add_argument("--text", default="用一句话介绍 Python。")
args = ap.parse_args()
print("=== chat_text ===")
print(chat_text(args.text, api_key=args.api_key))#!/usr/bin/env python3
# -*- coding: utf-8 -*-
"""AIMS 平台功能型 API 公共调用 helper（付费 skill 共用）。
能力：
- call_functional_api(resource_id, arguments) 统一调用平台托管功能型 API
- needs_confirm → 抛出 NeedsConfirmation（结构化，带真实报价）
- estimate_cost(resource_id, units) 免费报价（不调上游，0 花费）
协议（2026-09-22 platform-paid-confirm-protocol）：
付费工具默认 **confirm=False**（安全默认）。平台返回 -32006 时不扣费，
本模块把它翻译成 NeedsConfirmation 异常（带 estimated_cost_yuan），
而不是笼统的 RuntimeError——这样 agent 能把真实报价展示给用户，
用户确认后加 --approved 重试。
环境：依赖 AIMS_API_KEY 环境变量或 --api-key
"""
import argparse
import json
import os
import time
import urllib.request
AIMS_URL = "https://aimsgateway.cn/mcp/"
# 内部源名 → 对外目录名（与平台 application/services/public_naming.py 的
# PUBLIC_SOURCES 对齐；未登记的源原样透出）。estimate 用它把内部 resource_id
# 映射成 list_functional_apis 返回的对外 id。
_EXTERNALIZE = {"serpapi": "web", "hunter": "email", "jev": "decision", "apis": "public-api"}
class NeedsConfirmation(RuntimeError):
"""付费工具未确认 —— 平台返回 -32006 / requires_confirmation。
仍未扣费。调用方应把 estimated_cost_yuan 展示给用户，
用户同意后带 confirm=True 重试。
继承 RuntimeError 是为了向后兼容既有 ``except RuntimeError`` 调用方。
"""
def __init__(self, resource_id, estimated_cost_yuan=0.0, basis="", raw=None, hint=""):
self.resource_id = resource_id
self.estimated_cost_yuan = float(estimated_cost_yuan or 0.0)
self.basis = basis or ""
self.raw = raw if isinstance(raw, dict) else {}
self.hint = hint or ""
super().__init__(
f"付费工具需确认: {resource_id} 约 ¥{self.estimated_cost_yuan:.2f} "
f"(价格依据: {self.basis or 'unknown'})。"
f"请把该报价展示给用户；确认后加 --approved 重试。未确认不会扣费。"
)
def to_dict(self):
"""给 CLI 输出的结构化载荷（agent 可直接机读）。"""
return {
"ok": False,
"needs_confirmation": True,
"resource_id": self.resource_id,
"estimated_cost_yuan": self.estimated_cost_yuan,
"cost_basis": self.basis or "unknown",
"hint": self.hint or "把费用展示给用户；用户确认后加 --approved 重试",
}
def _external_rid(resource_id):
"""内部 resource_id → 对外目录 id。serpapi/google → web/google"""
src, _, rest = (resource_id or "").strip().partition("/")
ext = _EXTERNALIZE.get(src, src)
return f"{ext}/{rest}" if rest else ext
def _maybe_needs_confirmation(resource_id, parsed):
"""把平台的 -32006 载荷翻译成 NeedsConfirmation；不是则返回 None。
兼容三种形态：
A {"error": {"code": -32006, "data": {...}}} 平台 JSON-RPC 包装
B {"code": -32006, "data": {...}} 已解包的 error 对象
C {"requires_confirmation": true, ...} 直接是 data
"""
if not isinstance(parsed, dict):
return None
err = parsed.get("error")
if isinstance(err, dict) and err.get("code") == -32006:
d = err.get("data") if isinstance(err.get("data"), dict) else {}
return NeedsConfirmation(resource_id, d.get("estimated_cost_yuan"),
d.get("cost_basis", ""), err, d.get("hint", ""))
if parsed.get("code") == -32006:
d = parsed.get("data") if isinstance(parsed.get("data"), dict) else {}
return NeedsConfirmation(resource_id, d.get("estimated_cost_yuan"),
d.get("cost_basis", ""), parsed, d.get("hint", ""))
if parsed.get("requires_confirmation") is True:
return NeedsConfirmation(resource_id, parsed.get("estimated_cost_yuan"),
parsed.get("cost_basis", ""), parsed, parsed.get("hint", ""))
return None
def raise_if_needs_confirmation(resource_id, parsed):
"""载荷是 -32006 时抛 NeedsConfirmation，否则原样返回 parsed。
给自建 _rpc_call 的 skill 复用（它们拿到 isError 载荷后调这个，
就能和走本模块的 skill 有同一套结构化确认语义）。
"""
nc = _maybe_needs_confirmation(resource_id, parsed)
if nc is not None:
raise nc
return parsed
# ---------- 鉴权 & 协议 ----------
def _get_key(api_key=None):
key = api_key or os.environ.get("AIMS_API_KEY")
if not key:
raise RuntimeError(
"缺少 AIMS API Key：请设置环境变量 AIMS_API_KEY，或调用方传 --api-key"
)
return key
def _rpc(url, key, method, params, mid, tries=3, timeout=120):
body = json.dumps({"jsonrpc": "2.0", "id": mid, "method": method, "params": params}).encode()
headers = {"Content-Type": "application/json", "Authorization": f"Bearer {key}"}
last = None
for _ in range(tries):
try:
req = urllib.request.Request(url, data=body, method="POST", headers=headers)
with urllib.request.urlopen(req, timeout=timeout) as r:
return json.loads(r.read().decode())
except Exception as e: # noqa: BLE001
last = e
time.sleep(2)
raise RuntimeError(f"MCP 调用失败: {last}")
def _handshake(key):
_rpc(AIMS_URL, key, "initialize",
{"protocolVersion": "2025-03-26", "capabilities": {},
"clientInfo": {"name": "office-skills-func-api", "version": "1.0"}}, 1)
try:
_rpc(AIMS_URL, key, "notifications/initialized", {}, 2)
except Exception:
pass
# ---------- 功能型 API 调用 ----------
def call_functional_api(resource_id, arguments=None, api_key=None, mid=3, confirm=False):
"""调 AIMS 平台的功能型 API。
Args:
resource_id: 资源 ID，9 个可选值：
- hunter/account
- hunter/domain-search
- hunter/email-finder
- hunter/email-verifier
- serpapi/account
- serpapi/{engine}
- apis/catalog
- apis/{slug}
- apis/{slug}/{path}
arguments: dict，参数键值对（按上游 API 的 params 字段说明）
api_key: 可选 Bearer Token（默认读 env）
confirm: True 时附 confirm:true，平台放行付费工具；False 时平台返回
-32006 / requires_confirmation，未付费不扣费（默认 False，安全默认）
返回 dict（平台直接返回上游响应 + 末尾 `_aimschina` 元数据）
抛出 RuntimeError 当 isError=True
"""
key = _get_key(api_key)
_handshake(key)
args = dict(arguments or {})
if confirm:
args["confirm"] = True
resp = _rpc(AIMS_URL, key, "tools/call",
{"name": "aims.call_functional_api",
"arguments": {"resource_id": resource_id, "arguments": args}}, mid)
is_err = resp.get("result", {}).get("isError")
text = resp.get("result", {}).get("content", [{}])[0].get("text", "{}")
parsed = json.loads(text)
if is_err:
_nc = _maybe_needs_confirmation(resource_id, parsed)
if _nc is not None:
raise _nc
raise RuntimeError(f"{resource_id} 错误: {parsed}")
return parsed
# ---------- 9 个快捷封装 ----------
def hunter_account(api_key=None, confirm=False):
"""hunter 账户与配额（免费）。"""
return call_functional_api("hunter/account", {}, api_key=api_key, confirm=confirm)
def hunter_domain_search(domain, limit=10, offset=0, type=None,
seniority=None, department=None, api_key=None, confirm=False):
"""按域名搜邮箱。返回 {"domain":..., "emails":[{value,type,confidence,position,...}], "_aimschina":{cost_yuan,...}}"""
args = {"domain": domain, "limit": str(limit)}
if offset:
args["offset"] = str(offset)
if type:
args["type"] = type
if seniority:
args["seniority"] = seniority
if department:
args["department"] = department
return call_functional_api("hunter/domain-search", args, api_key=api_key, confirm=confirm)
def hunter_email_finder(domain, full_name=None, first_name=None, last_name=None,
max_duration=10, api_key=None, confirm=False):
"""按人名 + 域名推断邮箱。"""
args = {"domain": domain, "max_duration": str(max_duration)}
if full_name:
args["full_name"] = full_name
elif first_name and last_name:
args["first_name"] = first_name
args["last_name"] = last_name
return call_functional_api("hunter/email-finder", args, api_key=api_key, confirm=confirm)
def hunter_email_verifier(email, api_key=None, confirm=False):
"""验证邮箱是否可投递。返回 {"status": "valid"|"invalid"|"accept_all"|"webmail"|"disposable"|"unknown", ...}"""
return call_functional_api("hunter/email-verifier", {"email": email}, api_key=api_key, confirm=confirm)
def serpapi_account(api_key=None, confirm=False):
"""serpapi 账户与配额（免费）。"""
return call_functional_api("serpapi/account", {}, api_key=api_key, confirm=confirm)
def serpapi_search(engine, q=None, num=10, page=1, gl=None, hl=None,
location=None, api_key=None, confirm=False):
"""透传到任意 serpapi 引擎（google / google_maps / google_shopping 等）。
engine 必填，例如 "google_maps" 拿 POI、"google" 拿网页搜索结果、"google_shopping" 拿商品。
实际调 serpapi.engine 工具（不是走 functional_api 路由）。
confirm=True 时附 confirm:true 放行付费工具；默认 False 平台返回 -32006 不扣费。
"""
args = {"engine": engine, "num": str(num), "page": str(page)}
if q:
args["q"] = q
if gl:
args["gl"] = gl
if hl:
args["hl"] = hl
if location:
args["location"] = location
if confirm:
args["confirm"] = True
key = _get_key(api_key)
_handshake(key)
resp = _rpc(AIMS_URL, key, "tools/call",
{"name": "serpapi.engine", "arguments": args}, 3)
is_err = resp.get("result", {}).get("isError")
text = resp.get("result", {}).get("content", [{}])[0].get("text", "{}")
parsed = json.loads(text)
if is_err:
_nc = _maybe_needs_confirmation("serpapi/" + str(engine or ""), parsed)
if _nc is not None:
raise _nc
raise RuntimeError(f"serpapi.engine({engine}) 错误: {parsed}")
return parsed
def apis_catalog(api_key=None):
"""列出所有 apis 目录（450+ 免密钥公共 API）。"""
return call_functional_api("apis/catalog", {}, api_key=api_key)
def apis_slug(slug, api_key=None):
"""调 apis/{slug} 顶层端点（GET）。"""
return call_functional_api(f"apis/{slug}", {}, api_key=api_key)
def apis_slug_path(slug, path, method="GET", body=None, params=None, api_key=None):
"""调 apis/{slug}/{path} 任意端点。
Args:
slug: 例如 "openweather"
path: 例如 "data/2.5/weather"
method: GET / POST / PUT / DELETE
body: POST/PUT body
params: query 参数
"""
args = {"method": method}
if body is not None:
args["body"] = body
if params is not None:
args["params"] = params
return call_functional_api(f"apis/{slug}/{path}", args, api_key=api_key)
# ---------- 免费报价 estimate（0 上游花费） ----------
# 本地兜底价：**只登记实测过的资源**（来源：lead-miner install.md §17.4，
# 实测日期 2026-09-17）。平台实时价取不到时才用它，且 cost_basis 会明确标
# local_fallback + price_note 提示可能有偏差——绝不拿它冒充权威报价。
# 没实测过的资源**一律不给兜底价**（宁可 ok=False，也不猜）。
LOCAL_FALLBACK_PRICE_YUAN = {
"serpapi/google_maps": 0.21,
"hunter/domain-search": 0.204,
"hunter/email-verifier": 0.10,
}
def estimate_cost(resource_id, units=1, api_key=None):
"""纯报价：走**免费**的 aims.list_functional_apis 读实时单价，不调上游。
这是唯一可靠的报价途径——catalog 声明价与实收价实测差 ~18%，
而 list_functional_apis 返回的是平台已折算的 effective 单价
（observed 实测价优先，缺失才回落 declared）。
Args:
resource_id: 内部 resource_id，如 "serpapi/google" / "hunter/domain-search"
units: 预计调用次数
api_key: 可选 Bearer Token（默认读 env）
Returns:
dict: {ok, resource_id, external_resource_id, units, unit_cost_yuan,
cost_basis, total_yuan, upstream_called: False, note}
查不到价时返回 ok=False（不抛异常——报价失败不该让调用方崩）
"""
ext = _external_rid(resource_id)
base = {
"resource_id": resource_id,
"external_resource_id": ext,
"units": int(units or 1),
"upstream_called": False,
}
def _fallback(note):
"""平台价拿不到时用本地实测兜底；没登记的资源保持 ok=False（不猜价）。"""
unit = LOCAL_FALLBACK_PRICE_YUAN.get(resource_id)
if unit is None:
return False
base.update({
"ok": True,
"unit_cost_yuan": round(unit, 4),
"cost_basis": "local_fallback",
"billing_unit": "per_call",
"total_yuan": round(unit * base["units"], 4),
"price_note": ("本地登记的【实测兜底价】(2026-09-17)，非平台实时价，"
"实收可能偏差约 ±18%；要准数请配好 AIMS_API_KEY 重跑 estimate。"),
"note": note,
})
return True
try:
key = _get_key(api_key)
except RuntimeError as e:
if not _fallback("用本地实测兜底价（未触达平台）"):
base.update({"ok": False, "error": str(e),
"note": "estimate 需要 AIMS_API_KEY 才能读到平台实时单价"})
return base
try:
_handshake(key)
resp = _rpc(AIMS_URL, key, "tools/call",
{"name": "aims.list_functional_apis",
"arguments": {"limit": 200}}, 7)
text = resp.get("result", {}).get("content", [{}])[0].get("text", "{}")
payload = json.loads(text)
except Exception as e: # noqa: BLE001
if not _fallback("用本地实测兜底价（平台单价查询失败）"):
base.update({"ok": False, "error": f"读取平台单价失败: {e}"})
return base
items = payload.get("apis") or []
hit = None
for it in items:
if isinstance(it, dict) and it.get("resource_id") in (ext, resource_id):
hit = it
break
if hit is None:
if _fallback("平台目录里没有该资源，改用本地实测兜底价"):
base["not_in_catalog"] = True
return base
base.update({
"ok": False,
"error": f"平台目录里没找到 {ext}（内部 id: {resource_id}）",
"note": "单价未知——不要凭猜测报给用户；请确认该资源是否已上架/被 chat 策略隐藏",
"available_count": len(items),
})
return base
unit = float(hit.get("unit_cost_yuan") or 0.0)
base.update({
"ok": True,
"name": hit.get("name") or "",
"unit_cost_yuan": round(unit, 4),
"cost_basis": hit.get("price_basis") or "declared",
"billing_unit": hit.get("billing_unit") or "per_call",
"total_yuan": round(unit * base["units"], 4),
"note": "本报价未调用上游、未扣费；用户确认后加 --approved 真实执行",
})
return base
def emit_estimate(resource_id, units=1, api_key=None):
"""CLI 用：打印报价 JSON 并以退出码结束（0=有报价 / 1=查不到）。
在 skill 里这样用（parse_args 之后、真调付费接口之前）：
if args.estimate:
emit_estimate("serpapi/google")
"""
est = estimate_cost(resource_id, units=units, api_key=api_key)
print(json.dumps(est, ensure_ascii=False, indent=2))
raise SystemExit(0 if est.get("ok") else 1)
def add_estimate_flag(parser):
"""给 skill 的 argparse 统一加 --estimate（免费报价，不调上游）。"""
parser.add_argument(
"--estimate", action="store_true",
help="只报预估费用，不调用上游、不扣费（免费）",
)
return parser
# ---------- 列出当前所有可用 resource_id ----------
KNOWN_RESOURCES = [
"hunter/account",
"hunter/domain-search",
"hunter/email-finder",
"hunter/email-verifier",
"serpapi/account",
"serpapi/{engine}",
"apis/catalog",
"apis/{slug}",
"apis/{slug}/{path}",
]
if __name__ == "__main__":
import argparse
ap = argparse.ArgumentParser(description="AIMS 功能型 API helper 自检")
ap.add_argument("--api-key", default=None)
ap.add_argument("--resource", default="hunter/account", help=f"资源 ID，已知: {KNOWN_RESOURCES}")
ap.add_argument("--args", default="{}", help="JSON 字符串参数")
args = ap.parse_args()
print(f"=== call_functional_api({args.resource}) ===")
parsed_args = json.loads(args.args)
result = call_functional_api(args.resource, parsed_args, api_key=args.api_key)
print(json.dumps(result, ensure_ascii=False, indent=2)[:2000])