@3-/aiapi 0.1.76 → 0.1.78

package/check/GEN.js

@@ -0,0 +1,41 @@
+import TYPE from '../TYPE.js';
+
+export default {
+  type: TYPE.ARRAY,
+  description: '基于对话分析生成的、可进行外部搜索验证的投资洞察列表（请把公司提及的个案数据，转为对行业搜索研究的命题）',
+  minItems: 0,
+  items: {
+    type: TYPE.OBJECT,
+    properties: {
+      title: {
+        type: TYPE.STRING,
+        description: '简短的标题，概述研究内容'
+      },
+      question: {
+        type: TYPE.STRING,
+        description: '从对话中提炼出的、具有明确事实属性且可通过外部搜索验证的关键行业洞察，是可以被证明或者证伪的命题。请避免无法验证的主观形容词。'
+      },
+      zh: {
+        type: TYPE.ARRAY,
+        description: '用于验证该洞察真伪的搜索关键词列表(中文)',
+        minItems: 0,
+        items: {
+          type: TYPE.STRING
+        }
+      },
+      en: {
+        type: TYPE.ARRAY,
+        description: '用于验证该洞察真伪的搜索关键词列表(英文)',
+        minItems: 0,
+        items: {
+          type: TYPE.STRING
+        }
+      },
+      reason: {
+        type: TYPE.STRING,
+        description: '分析为何搜索研究该洞察对判断决策至关重要'
+      }
+    },
+    required: ['title', 'question', 'zh', 'en', 'reason']
+  }
+};

package/check/SEARCH.js

@@ -0,0 +1,57 @@
+import TYPE from '../TYPE.js';
+
+export default {
+  type: TYPE.OBJECT,
+  properties: {
+    研究: {
+      type: TYPE.ARRAY,
+      minItems: 1,
+      description: `请执行以下结构化的研究报告撰写任务：
+1. 章节拆分规划：首先，请根据研究主题的内在逻辑，将报告内容拆分为3-5个主要章节，每个章节需有明确的主题和研究范围。
+2. 研究过程汇报：其次，详细记录并汇报研究实施的完整过程，包括但不限于：研究方法选择、数据收集途径、分析工具使用、关键节点时间线等。
+3. 资料汇总整理：然后，在最后一章中，基于汇总的资料进行严谨的逻辑推理，分析数据间的关联性和规律，最终得出明确、有依据的研究结论。`,
+      items: {
+        type: TYPE.OBJECT,
+        required: ['title', 'md'],
+        properties: {
+          title: {
+            type: TYPE.STRING,
+            description: '章节标题'
+          },
+          md: {
+            type: TYPE.STRING,
+            description: '章节正文，markdown格式(禁止包含标题)'
+          }
+        }
+      }
+    },
+    结论: {
+      type: TYPE.STRING,
+      description: '一句话概述研究结论（支持还是不支持命题）'
+    },
+    文献: {
+      type: TYPE.ARRAY,
+      description: '参考资料',
+      minItems: 1,
+      items: {
+        type: TYPE.OBJECT,
+        required: ['title', 'brief', 'url'],
+        properties: {
+          title: {
+            type: TYPE.STRING,
+            description: '标题'
+          },
+          brief: {
+            type: TYPE.STRING,
+            description: '概述文章内容'
+          },
+          url: {
+            type: TYPE.STRING,
+            description: '链接'
+          }
+        }
+      }
+    }
+  },
+  required: ['结论', '研究', "文献"]
+};

package/fmt.js

@@ -1,8 +1,13 @@
 #!/usr/bin/env -S node --trace-uncaught --expose-gc --unhandled-rejections=strict --experimental-wasm-modules
 import fmtJson from './fmtJson.js';
 
-import fmtJsonMd from './fmtJsonMd.js';
+import partition from './partition.js';
 
 export default async(chat, txt) => {
-  return fmtJsonMd((await fmtJson(chat, txt)));
+  var pli;
+  pli = (await partition(chat, txt));
+  if (!pli.length) {
+    return '';
+  }
+  return fmtJson(chat, pli);
 };

package/fmtJson.js

@@ -1,16 +1,11 @@
 #!/usr/bin/env -S node --trace-uncaught --expose-gc --unhandled-rejections=strict --experimental-wasm-modules
 import fmtSeg from './fmtSeg.js';
 
-import partition from './partition.js';
+import fmtJsonMd from './fmtJsonMd.js';
 
-export default async(chat, txt) => {
-  var pli;
-  pli = (await partition(chat, txt));
-  if (!pli.length) {
-    return [];
-  }
-  return Promise.all(pli.map(async([title, li]) => {
+export default async(chat, pli) => {
+  return fmtJsonMd((await Promise.all(pli.map(async([title, li]) => {
     console.log('\n---\n→ ' + title + '\n' + li.join('\n') + '\n---\n');
     return [title, (await fmtSeg(chat, li.join('\n')))];
-  }));
+  }))));
 };

package/fmtJsonMd.js

@@ -3,6 +3,8 @@ var txtFmt;
 
 import TxtLi from '@3-/txt_li';
 
+import refmt from './refmt.js';
+
 txtFmt = (txt) => {
   return TxtLi(txt).join('\n\n');
 };
@@ -12,15 +14,15 @@ export default (title_json_li) => {
   md_li = [];
   for (x of title_json_li) {
     [title, li] = x;
-    md_li.push('# ' + title);
+    md_li.push('## ' + title);
     for (y of li) {
       ({题, 问, 答} = y);
       答 = txtFmt(答).trim();
       if ((答.startsWith('1. ')) || 答.endsWith(':') || 答.endsWith('：')) {
         答 = '\n' + 答;
       }
-      md_li.push('## ' + 题 + '\n问: ' + txtFmt(问).trimEnd() + '\n\n答: ' + 答 + '\n');
+      md_li.push('### ' + 题 + '\n问: ' + txtFmt(问).trimEnd() + '\n\n答: ' + 答 + '\n');
     }
   }
-  return md_li.join('\n');
+  return md_li.map(refmt).join('\n');
 };

package/gemini.js

@@ -34,7 +34,10 @@ export default (token_li, model = 'gemini-3-flash-preview') => {  // model='gemi
     if (schema) {
       body.generationConfig = {
         responseMimeType: 'application/json',
-        responseJsonSchema: schema
+        responseJsonSchema: schema,
+        thinkingConfig: {
+          thinkingLevel: 'high'
+        }
       };
     }
     if (option) {

package/package.json

@@ -1 +1 @@
-{"name":"@3-/aiapi","version":"0.1.76","repository":{"type":"git","url":"git+https://atomgit.com/i18n/lib.git"},"homepage":"https://atomgit.com/i18n/lib/tree/dev/aiapi","author":"i18n.site@gmail.com","license":"MulanPSL-2.0","exports":{".":"./lib.js","./*":"./*"},"files":["./*"],"devDependencies":{"@3-/read":"^0.1.4"},"scripts":{},"type":"module","dependencies":{"@3-/retry":"^0.0.2","@3-/rm_cn_space":"^0.1.1","@3-/sleep":"^0.0.4","@3-/txt_li":"^0.1.5","@3-/utf8":"^0.0.4","lodash-es":"^4.17.21"}}
+{"name":"@3-/aiapi","version":"0.1.78","repository":{"type":"git","url":"git+https://atomgit.com/i18n/lib.git"},"homepage":"https://atomgit.com/i18n/lib/tree/dev/aiapi","author":"i18n.site@gmail.com","license":"MulanPSL-2.0","exports":{".":"./lib.js","./*":"./*"},"files":["./*"],"devDependencies":{"@3-/read":"^0.1.4"},"scripts":{},"type":"module","dependencies":{"@3-/retry":"^0.0.2","@3-/rm_cn_space":"^0.1.1","@3-/sleep":"^0.0.4","@3-/txt_li":"^0.1.5","@3-/utf8":"^0.0.4","lodash-es":"^4.17.21"}}

package/refmt.js

@@ -0,0 +1,2 @@
+export default (txt) =>
+  txt.replaceAll("\\n", "\n").replaceAll("“", "「").replaceAll("”", "」");

package/researchFmt.js

@@ -0,0 +1,49 @@
+#!/usr/bin/env -S node --trace-uncaught --expose-gc --unhandled-rejections=strict --experimental-wasm-modules
+import fmtJson from './fmtJson.js';
+
+import partition from './partition.js';
+
+import GEN from './check/GEN.js';
+
+import SEARCH from './check/SEARCH.js';
+
+import refmt from './refmt.js';
+
+export default async(chat, txt) => {
+  var fmt, gen_txt, pli, search;
+  pli = (await partition(chat, txt));
+  if (!pli.length) {
+    return [];
+  }
+  fmt = fmtJson(chat, pli);
+  gen_txt = pli.map(([title, li]) => {
+    return '# ' + title + '\n' + li.join('\n');
+  }).join('\n');
+  search = Promise.all(((await chat(gen_txt, GEN, "你是专业的风险投资人"))).map(async(i) => {
+    var body, en, question, reason, title, zh, 文献, 研究, 结论;
+    // console.log i
+    ({title, question, zh, en, reason} = i);
+    body = title + '\n研究命题: ' + question + '\n中文搜索词: ' + zh + '\n英文搜索词: ' + en;
+    console.log('\n# ' + body);
+    ({结论, 研究, 文献} = (await chat('请基于搜索，对以下命题深度研究:\n' + body, SEARCH, '利用搜索工具进行客观理性的研究分析', {
+      tools: [
+        {
+          google_search: {}
+        },
+        {
+          url_context: {}
+        }
+      ]
+    })));
+    return '## ' + title.trim() + '\n\n**<u>问题:</u>** ' + question.trim() + '\n\n**<u>结论</u>:** ' + 结论.trim() + '\n\n' + 研究.map(({title, md}) => {
+      return '### ' + title + '\n\n' + md;
+    }).join('\n') + '\n\n### 参考资料\n\n' + 文献.map(({title, brief, url}, pos) => {
+      return (pos + 1) + '. [' + title + '](' + url + ') : ' + brief;
+    }).join('\n');
+  }));
+  [fmt, search] = (await Promise.all([fmt, search]));
+  if (search.length) {
+    fmt += '# 机器投研\n\n' + search.map(refmt).join('\n');
+  }
+  return fmt;
+};

package/seg.js

@@ -4,29 +4,30 @@ import TYPE from './TYPE.js';
 export default async(chat, txt_li) => {
   var split_li, 提示词;
   提示词 = `下文第1列为行号,第2列为对话内容,以tab分隔。
-请划分章节,每章以提问开始,包含几个问答,不要太长也不要太短,千字左右一章。
-输出章节标题和每章首个问题的行号及原文,输出格式为JSON数组:\n` + txt_li.map((i, pos) => {
+请划分章节,每章不要太长也不要太短,千字左右一章。
+输出章节标题、每章最后一句号的行号。
+输出格式为json数组:\n` + txt_li.map((i, pos) => {
     return (pos + 1) + '\t' + i.trim();
   }).join('\n');
   split_li = (await chat(提示词, {
     type: TYPE.ARRAY,
-    description: '章节和行号的列表',
+    description: '拆分文章为多个章节，每个章节包含一系列问答对',
     minItems: 1,
     items: {
       type: TYPE.OBJECT,
       properties: {
         题: {
-          description: '章节标题,要概括章节内容',
+          description: '章节标题(只写标题，不写注释)',
           type: TYPE.STRING
         },
         行: {
-          description: '该章最后一行的行号',
+          description: '该章最后一句的行号',
           type: TYPE.INTEGER
         }
       },
       required: ['题', '行']
     }
-  }, '你是专业资深的秘书'));
+  }, '你是专业资深的杂志编辑'));
   return split_li.map((i) => {
     return [i.题, i.行];
   });

package/check/GEN_QA.js

@@ -1,41 +0,0 @@
-import TYPE from '../TYPE.js';
-
-export default {
-  type: TYPE.ARRAY,
-  description: '事实提取与命题化。将自然语言主张拆解为可独立验证的布尔命题元组，为后续网络搜索查证做准备(如果觉得不太可被搜索验证，不要列出来)，如果事实不重要，不要列出来',
-  minItems: 0,
-  items: {
-    type: TYPE.OBJECT,
-    properties: {
-      原句: {
-        type: TYPE.STRING,
-        description: '来源的原始文本片段（去除语气助词、优化语言转录的可读性）'
-      },
-      实体: {
-        type: TYPE.STRING,
-        description: '命题的主体，必须是一个可以被明确搜索的关键词'
-      },
-      宾语: {
-        type: TYPE.STRING,
-        description: '核心核查点，具体的金额、具体的份额等'
-      },
-      命题: {
-        type: TYPE.STRING,
-        description: '完整的陈述句，必须是一个可以独立判定真伪的布尔命题'
-      },
-      如何搜索: {
-        type: TYPE.STRING,
-        description: '如何通过谷歌搜索查证此命题的真伪'
-      },
-      重要度: {
-        type: TYPE.INTEGER,
-        description: '0-10分，命题对于决策判断重要程度，分数越高越重要。有具体数字的内容，可以被搜索到的内容，会比较重要。竞争对手是谁创办的这种不重要。'
-      },
-      可查性: {
-        type: TYPE.INTEGER,
-        description: '0-10分，命题是否可以通过互联网搜索验证，分数越高代表容易被搜索查证。0表示是公司内部数据，无法搜索被验证'
-      }
-    },
-    required: ['实体', '宾语', '命题', '如何搜索', '原句', '可查性']
-  }
-};

package/check/STEP_2_RETRIEVAL_ROUTER.js

@@ -1,39 +0,0 @@
-import TYPE from '../TYPE.js';
-
-export default {
-  type: TYPE.ARRAY,
-  description: '第二阶段：检索可行性判断 (Self-RAG 滤网)。对每个命题进行检索必要性打分和隐私判定。',
-  minItems: 1,
-  items: {
-    type: TYPE.OBJECT,
-    properties: {
-      对应命题ID: {
-        type: TYPE.STRING,
-        description: '关联的第一阶段命题ID'
-      },
-      检索必要性得分: {
-        type: TYPE.NUMBER,
-        description: '0-1之间的分数，分数越高代表越需要检索'
-      },
-      隐私边界: {
-        type: TYPE.STRING,
-        description: '判定类别：可公开检索/半公开推论/内部隐私',
-        enum: ['可公开检索', '半公开推论', '内部隐私']
-      },
-      数据类型: {
-        type: TYPE.STRING,
-        description: '数据性质：硬数据（法律/备案等）或 软数据（侧面印证/舆情）',
-        enum: ['硬数据', '软数据']
-      },
-      是否需要尽调: {
-        type: TYPE.BOOLEAN,
-        description: '对于内部隐私或不可验证的数据，标记为True'
-      },
-      推断逻辑: {
-        type: TYPE.STRING,
-        description: '简述判定的理由'
-      }
-    },
-    required: ['对应命题ID', '检索必要性得分', '隐私边界', '数据类型']
-  }
-};

package/check/STEP_3_AGENT_PLANNING.js

@@ -1,57 +0,0 @@
-import TYPE from '../TYPE.js';
-
-export default {
-  type: TYPE.ARRAY,
-  description: '第三阶段：规划与工具调用 (Agentic Workflow)。将自然语言主张转化为可执行的验证程序步骤。',
-  minItems: 1,
-  items: {
-    type: TYPE.OBJECT,
-    properties: {
-      场景类型: {
-        type: TYPE.STRING,
-        description: '验证场景分类',
-        enum: ['数值验证', '逻辑验证', '负面排除', '其他']
-      },
-      目标命题ID: {
-        type: TYPE.ARRAY,
-        description: '该计划覆盖的命题ID列表',
-        items: {
-          type: TYPE.STRING
-        }
-      },
-      SOTA策略: {
-        type: TYPE.STRING,
-        description: '使用的策略名称，如 HyDE, ReAct, Query Expansion'
-      },
-      执行步骤: {
-        type: TYPE.ARRAY,
-        description: '具体的每一步执行动作',
-        items: {
-          type: TYPE.OBJECT,
-          properties: {
-            步骤序号: {
-              type: TYPE.NUMBER
-            },
-            步骤描述: {
-              type: TYPE.STRING,
-              description: '自然语言描述该步骤要做什么'
-            },
-            搜索关键词: {
-              type: TYPE.ARRAY,
-              description: '生成的搜索Query列表',
-              items: {
-                type: TYPE.STRING
-              }
-            },
-            预期动作: {
-              type: TYPE.STRING,
-              description: '执行的具体操作，如：提取Top5、对比数据、向量匹配'
-            }
-          },
-          required: ['步骤序号', '步骤描述', '搜索关键词']
-        }
-      }
-    },
-    required: ['场景类型', 'SOTA策略', '执行步骤']
-  }
-};

package/check/STEP_4_EVIDENCE_CHECK.js

@@ -1,54 +0,0 @@
-import TYPE from '../TYPE.js';
-
-export default {
-  type: TYPE.ARRAY,
-  description: '第四阶段：多源证据推理 (Multi-Hop Reasoning)。进行证据一致性校验与矛盾检测。',
-  minItems: 1,
-  items: {
-    type: TYPE.OBJECT,
-    properties: {
-      对应命题ID: {
-        type: TYPE.STRING
-      },
-      证据三角化状态: {
-        type: TYPE.STRING,
-        description: '证据的支持情况',
-        enum: ['直接支持', '直接反驳', '时间线矛盾', '数量级偏差', '证据缺失']
-      },
-      证据来源: {
-        type: TYPE.ARRAY,
-        description: '引用的具体证据源',
-        items: {
-          type: TYPE.OBJECT,
-          properties: {
-            来源名称: {
-              type: TYPE.STRING,
-              description: '来源标题或网站名'
-            },
-            链接: {
-              type: TYPE.STRING,
-              description: 'URL链接'
-            },
-            引文片段: {
-              type: TYPE.STRING,
-              description: '相关的原文片段'
-            }
-          }
-        }
-      },
-      判定详情: {
-        type: TYPE.STRING,
-        description: '具体的判定理由，解释为何支持或反驳'
-      },
-      时间线矛盾: {
-        type: TYPE.BOOLEAN,
-        description: '是否存在时间逻辑上的矛盾（如：成立前就拿订单）'
-      },
-      数量级偏差: {
-        type: TYPE.BOOLEAN,
-        description: '是否存在数量级或定义的营销性夸大'
-      }
-    },
-    required: ['对应命题ID', '证据三角化状态', '判定详情']
-  }
-};

package/check/STEP_5_ADVERSARIAL_REVIEW.js

@@ -1,59 +0,0 @@
-import TYPE from '../TYPE.js';
-
-export default {
-  type: TYPE.ARRAY,
-  description: '第五阶段：合成与对抗 (Adversarial Review)。引入红蓝军对抗，输出最终结论。',
-  minItems: 1,
-  items: {
-    type: TYPE.OBJECT,
-    properties: {
-      对抗辩论: {
-        type: TYPE.OBJECT,
-        description: '红蓝军自我博弈记录',
-        properties: {
-          律师陈述: {
-            type: TYPE.STRING,
-            description: 'Agent A (律师) 辩护词：尽力为创作者说法辩护，寻找合理解释'
-          },
-          检察官陈述: {
-            type: TYPE.STRING,
-            description: 'Agent B (检察官) 控诉词：尽力寻找漏洞，攻击其真实性'
-          }
-        },
-        required: ['律师陈述', '检察官陈述']
-      },
-      法官判决: {
-        type: TYPE.OBJECT,
-        description: 'Agent C (法官) 的最终裁决',
-        properties: {
-          可信度评分: {
-            type: TYPE.NUMBER,
-            description: '0-100分，分数越高越可信'
-          },
-          风险警示灯: {
-            type: TYPE.STRING,
-            description: '直观的风险等级',
-            enum: ['绿色-可靠', '黄色-警示', '红色-造假风险']
-          },
-          风险提示报告: {
-            type: TYPE.STRING,
-            description: '详细的风险点分析'
-          },
-          最终结论: {
-            type: TYPE.STRING,
-            description: '综合结论摘要'
-          },
-          建议追问: {
-            type: TYPE.ARRAY,
-            description: '建议投资经理进一步核实的问题清单',
-            items: {
-              type: TYPE.STRING
-            }
-          }
-        },
-        required: ['可信度评分', '风险警示灯', '最终结论']
-      }
-    },
-    required: ['对抗辩论', '法官判决']
-  }
-};

package/factCheck.js

@@ -1,189 +0,0 @@
-#!/usr/bin/env -S node --trace-uncaught --expose-gc --unhandled-rejections=strict --experimental-wasm-modules
-var PREFIX, SHOW_KIND, addUrl, circle, realUrl, txtLi, urlLi;
-
-import retry from '@3-/retry';
-
-import utf8d from '@3-/utf8/utf8d.js';
-
-import utf8e from '@3-/utf8/utf8e.js';
-
-// @3-/read
-// @3-/write
-SHOW_KIND = ['严重失实', '不正确'];
-
-PREFIX = `对下文问答中提及的事实做核查(不核查观点)。
-数据偏差不超过30%都当做基本一致,找不到信息当无法核实。
-必须搜索到明确的证伪证据并才算失实。
-只输出不正确/严重失实的核查。
-输出文本必须是简体中文，格式如下:
-- id:
-  标题: 要简短,几个词即可
-  观点:
-  事实: 须标注搜索到的事实网页, 完整描述观点错误所在(不引用其他核查)
-  失实度: ${SHOW_KIND.join(' / ')} / 基本一致 / 无法核实
----\n`;
-
-realUrl = async(url) => {
-  var err, r, status;
-  if (url.startsWith('http')) {
-    try {
-      r = (await fetch(url, {
-        method: 'HEAD',
-        redirect: 'follow'
-      }));
-      ({status} = r);
-      if (status === 200) {
-        ({url} = r);
-      } else {
-        console.error(status + ' :' + url);
-      }
-    } catch (error) {
-      err = error;
-      console.error(err);
-    }
-  }
-  return url;
-};
-
-circle = (num) => {
-  switch (false) {
-    case !(num > 0 && num <= 10):
-      return String.fromCodePoint(0x245F + num);
-    default:
-      return `[${num}]`;
-  }
-};
-
-urlLi = (id_li, url_li) => {
-  var i, r;
-  r = [];
-  for (i of id_li) {
-    r.push('[' + circle(i + 1) + '](' + url_li[i] + ')');
-  }
-  return r.join('');
-};
-
-addUrl = (text, items) => {
-  var bin, chunks, end, entry, j, len, output, pos, push, sorted, start;
-  output = '';
-  push = (bin) => {
-    output += utf8d(bin);
-  };
-  pos = 0;
-  sorted = items.sort(function(a, b) {
-    return a.segment.startIndex - b.segment.startIndex;
-  });
-  bin = utf8e(text);
-  for (j = 0, len = sorted.length; j < len; j++) {
-    entry = sorted[j];
-    ({
-      segment: {
-        startIndex: start,
-        endIndex: end
-      },
-      groundingChunkIndices: chunks
-    } = entry);
-    if (start > pos) {
-      push(bin.slice(pos, start));
-    }
-    push(bin.slice(start, end));
-    output += chunks;
-    pos = end;
-  }
-  if (pos < bin.length) {
-    push(bin.slice(pos));
-  }
-  return output;
-};
-
-txtLi = (txt) => {
-  var all_tag, i, id, pre, r, reset, t, tag, trim, txt_li;
-  r = [];
-  reset = () => {
-    all_tag = new Set(['标题', '观点', '事实', '失实度']);
-    if (t) {
-      r.push(t);
-    }
-    pre = t = void 0;
-  };
-  txt_li = txt.replaceAll('**', '').split('\n');
-  out: //;
-  for (i of txt_li) {
-    if (i.startsWith('- id:')) {
-      reset();
-      id = parseInt(i.slice(5).trim());
-      if (id) {
-        t = {id};
-      }
-    } else if (t) {
-      trim = i.replace('- ', '').trimStart();
-      for (tag of all_tag) {
-        if (trim.startsWith(tag + ':')) {
-          all_tag.delete(tag);
-          pre = tag;
-          t[tag] = trim.slice(tag.length + 1).trim();
-          if (tag === '失实度' && all_tag.size === 0) {
-            reset();
-          }
-          continue out;
-        }
-      }
-      if (pre && trim) {
-        t[pre] += '\n' + trim;
-      }
-    }
-  }
-  if (t) {
-    r.push(t);
-  }
-  return r;
-};
-
-export default retry(async(chat, li) => {
-  var content, groundingChunks, groundingSupports, i, map, msg, out, ref, ref1, uri, url_li, x;
-  msg = PREFIX + li.map((i, pos) => {
-    return 'id:' + (pos + 1) + '\n' + i;
-  }).join('\n---\n');
-  out = (await chat(msg, 0, 0, {
-    tools: {
-      google_search: {}
-    }
-  }));
-  ({
-    // write '/tmp/fact.json',JSON.stringify out
-    // out = JSON.parse read '/tmp/fact.json'
-    content,
-    groundingMetadata: {groundingChunks, groundingSupports}
-  } = out);
-  if (!groundingChunks) {
-    return new Map();
-  }
-  content = content.parts[0].text;
-  console.log(content);
-  url_li = [];
-  for (x of groundingChunks) {
-    ({
-      web: {uri}
-    } = x);
-    url_li.push(realUrl(uri));
-  }
-  url_li = (await Promise.all(url_li));
-  for (i of groundingSupports) {
-    i.groundingChunkIndices = urlLi(i.groundingChunkIndices, url_li);
-  }
-  map = new Map();
-  ref = txtLi(addUrl(content, groundingSupports));
-  for (i of ref) {
-    console.log(i);
-    if (!SHOW_KIND.includes((ref1 = i.失实度) != null ? ref1.split('[')[0] : void 0)) {
-      continue;
-    }
-    li = map.get(i.id);
-    if (!li) {
-      li = [];
-      map.set(i.id, li);
-    }
-    li.push(i);
-  }
-  return map;
-});

package/fmtWithFactCheck.js

@@ -1,32 +0,0 @@
-#!/usr/bin/env -S node --trace-uncaught --expose-gc --unhandled-rejections=strict --experimental-wasm-modules
-import fmtSeg from './fmtSeg.js';
-
-import partition from './partition.js';
-
-import GEN_QA from './check/GEN_QA.js';
-
-export default async(chat, txt) => {
-  var pli;
-  pli = (await partition(chat, txt));
-  if (!pli.length) {
-    return [];
-  }
-  return (await Promise.all(pli.map(async([title, li]) => {
-    var i, ref, t;
-    t = li.join('\n');
-    console.log('\n---\n→ ' + title + '\n' + t + '\n---\n');
-    ref = (await chat(t, GEN_QA, "请帮忙筛选出可以被搜索验证、影响决策的核心问题。如果是公司内部的数据、资料，不要列成搜索问题。如果搜索主体的名字不明确，不要列成问题。"));
-    for (i of ref) {
-      if (i.可查性 > 6 && i.重要度 > 6) {
-        console.log(i);
-      }
-    }
-  })));
-};
-
-// return Promise.all
-//   console.log '\n---\n→ '+title+'\n'+li.join('\n')+'\n---\n'
-//   [
-//     title
-//     await fmtSeg(chat, li.join('\n'))
-//   ]