pi-provider-string-ai 0.0.0-stage → 0.1.0-beta.1

package/CHANGELOG.md

@@ -0,0 +1,40 @@
+# 变更记录
+
+## 0.1.0-beta.1
+
+- 首个公开 npm 测试版本，使用 `beta` 渠道；不作为稳定版发布。
+- 增加 npm 安装、固定版本与卸载说明；补充仓库元数据和显式发布配置。
+- 保持 Provider 生产源码不变；保留 `UNLICENSED`，本次不自行决定开源许可证。
+- 实际包仅包含 manifest、README、CHANGELOG 和四个 Provider 源文件，不包含宿主补丁、凭据、依赖目录及审计产物。
+- 原版 Pi 1.4.0 的 SEC-01 限制继续存在；真实 String AI 服务尚未完成验收，模拟工具闭环不等于生产可用性承诺。
+
+## 0.1.0-dev.0（未发布）
+
+### 普通官方 Pi 接入收敛（2026-10-23）
+
+- 用户确认正式端点后，缺省使用 `https://www.string.ink/v1`，普通流程不再要求模拟宿主或手工填写地址。
+- 新增可选择的 Pi 内置 OpenAI Responses 精确 ID 参考模板；显式档案优先，未知 ID 不猜测。模板能力/费用不代表 String 实测或分组账单。
+- 保留显式 `models: []` 的限制；自定义端点默认不启用参考模板，不静默迁移用户文件。
+- 完善原生登录说明、帮助与脱敏状态/刷新诊断；分组随 Key 绑定，不新增分组参数。
+- 请求终检增加 `store:false`，不将其宣传为服务或客户端不保存日志。
+- 新增未修改官方 Pi 的参考模板 manifest 集成与实际打包验证；具体结果另见 `docs/用户接入改进记录.md`，不沿用历史补丁运行时全绿数字。
+- README 改为官方 Pi 使用入口，模拟演示单列。原版组合器的 SEC-01 未修复且发布风险仍需明确接受或解决。
+
+### 历史开发与模拟验收
+
+- 建立独立 ESM TypeScript Pi 扩展包；宿主 SDK 使用 peerDependencies，开发版本由锁文件固定。
+- 实现严格配置校验、HTTPS 地址规范化、有限超时与响应大小的模型目录发现。
+- 注册 `string-ai`，复用原生 API Key 登录和 Responses 适配器；新增状态与手动刷新命令。
+- 模型可用性限定为服务目录与经确认能力档案的交集；不内置猜测的生产端点、模型或价格。
+- 添加回环模拟测试、宿主集成验证及包内容检查；各项实际结果见工作区的 Markdown 验证报告。
+- 修复 Pi 1.4.0 manifest/jiti 对适配器子路径的解析问题，使用宿主支持的 compat 原生工厂；支持默认 auto 固定走 SSE，继续拒绝显式 WebSocket。
+
+- 修复 LOGIC-01：原 `onPayload` 完成后和原生 SDK 序列化后验证最终 model/stream，保留合法回调和单次序列化语义。
+- SEC-01 本地修复：新增可选 `validateRequest` 准入与分发保留契约，覆盖隔离宿主 unbundled 与 bundled CLI；原安装不改，上游 Pi 1.4.0 仍有该问题。
+- 新增 `npm run demo`：无需全局安装 Pi/真实 Key，真实终端搭配回环模拟模型完成受限文件工具演示；`demo:smoke` 验证同一 CLI 的 RPC 路径。
+- 新增 `npm run test:local`：在独立运行时执行单测、集成、打包、类型和 lint 门；审查修复后父任务 Node22/24 均为184/184单测、6/6集成及其余门通过。
+- 修复运行时静态硬链接写穿及补丁/CLI 预检缺口；已有文件改为非截断替换，未知文件不自动删除。
+- 演示专用宿主在原生命令分发前限制 export/share/import/shell 等入口；smoke 按完整成功终态验收，拒绝完整文案后失败、缺终态或取消。第二轮两路独立复核均通过，结论仅限本地模拟体验。
+- 新增本地体验与宿主修复 Markdown 指南；真实 API 和公开发布仍未执行。
+
+没有生产服务修改、鉴权真实模型联调、npm 发布或 Git 提交。已按用户授权进行正式站点无凭据只读探测和生产版本标识核查；未读取真实 Key。当前面向用户本机限额试用，不构成正式支持承诺。模拟演示仍不得填真实 Key。

package/README.md

@@ -1,3 +1,156 @@
-# Temporary Holding Version
+# String AI Pi Provider
 
-This version is a temporary placeholder for this package. An operational version to replace this has been submitted for review and is awaiting a staged release.
+为**官方 Pi** 增加 `string-ai` 提供商：复用原生 API Key 登录、模型选择、Responses 流式适配器和文件/终端工具，不新增网关或定制 Agent。
+
+**测试版 `0.1.0-beta.1`，使用 npm `beta` 渠道，不是稳定版。** 真实 String AI 模型调用尚未完成验收，官方 Pi 1.4.0 的 SEC-01 限制仍存在（见下方安全边界）。仅建议在独立测试目录使用限额、可撤销的普通 API Key 试用；不把回环模拟结果或 npm 可安装当成生产可用性保证。
+
+## 本机真实试用
+
+### 1. 官网创建 Key
+
+在 `https://www.string.ink/` 创建普通 API Key，选择支持 **Responses、第三方客户端和目标模型** 的分组。分组已绑定 Key，插件不再要求选分组，也不发送额外 `group` 参数。不要使用 WebChat 内部 Key 或浏览器登录态。
+
+### 2. 在官方 Pi 安装插件
+
+发布后可固定安装此测试版：
+
+```sh
+pi --version
+pi install npm:pi-provider-string-ai@0.1.0-beta.1
+pi list
+```
+
+若要跟随测试渠道，可安装 `npm:pi-provider-string-ai@beta`。已使用本地目录版本的用户，应先用 `pi remove <原本地插件路径>` 移除原来源，避免重复注册同名 Provider。
+
+本轮已用官方 Pi `1.4.0` 在 Windows / Node `22.23.2`、`24.21.0` 验证普通插件加载、模拟工具闭环及实际包产物；引擎最低声明为 Node.js `>=22.19.0`，不代表所有满足声明的版本均已实测。开发者仍可使用 `pi install <本地源码目录>` 直接引用源码，不使用项目内 `.runtime` 副本；普通用户使用上方 npm 安装方式。尚未验证的 Pi 版本不属于支持承诺；`peerDependencies: "*"` 遵循 Pi 包规范，不是全版本兼容声明。
+
+在专用测试项目目录启动 `pi`。已有窗口使用 `/reload` 或重启。
+
+### 3. 登录、选择模型
+
+```text
+/login string-ai
+/model
+```
+
+Key 只在本机 Pi 提示中输入，不发聊天、不放命令参数/源码/截图。Pi 1.4.0 原生 secret 输入并非真正遮罩，登录时避免录屏或共享终端；原生认证存储不是加密保险库。
+
+Pi TUI 登录成功后自动刷新模型；从 `/model` 选择 `string-ai` 下当前可见的模型。**不需要登录 OpenAI/ChatGPT，也不需要填写 Codex TOML。** 默认 Base URL 为 `https://www.string.ink/v1`，全新安装通常无需 `string-ai.json`。
+
+先测试短文本，再在测试目录做“读文件、修改、写测试、运行测试”。检查实际文件和测试输出。`gpt-6-astra` 只有在当前 Key 返回并出现在列表中时才能选；不要把示例当可用性保证。
+
+辅助命令：
+
+- `/string-ai-help`：查看流程、分组和安全提示，不联网。
+- `/string-ai-status`：查看认证、模型、缺档案、参考模板和过期状态，不联网。
+- `/string-ai-refresh`：换分组或诊断时手动重新获取模型目录；不发送推理请求。
+
+## 模型能力与费用
+
+可选模型来自**当前 Key 的服务目录**，不是 Pi 内置模型全集。模型 ID 必须精确匹配，不按前缀、`owned_by` 或显示名猜测能力。
+
+1. 显式配置的 String AI 模型档案优先。
+2. 默认官方端点、且未显式提供 `models` 时，可复用 Pi 内置 OpenAI Responses 同 ID 的**兼容参考模板**。名称有“Pi参考”标记，状态有参考模型数量。
+3. 未匹配模型保持不可选；不会给未知模型虚构上下文、输出上限或免费价格。
+
+**参考模板不是 String 实测能力；Pi 显示的费用是上游参考估算，不是当前 Key 分组的结算账单。** 实际费用、限额、路由与可用能力以官网和该 Key 的真实调用为准。参考模板保留原生推理档位和费用阶梯，但不复制上游请求头、地址、采样参数或专有兼容开关。
+
+登录并确认模型可用后，如需 `xhigh`，可使用 Pi 原生参数：
+
+```powershell
+pi --provider string-ai --model gpt-6-astra --thinking xhigh
+```
+
+不强制所有用户使用最高推理档位；具体档位仍受模型模板和服务支持限制。`review_model`、`goals`、客户端网络权限、WSL 确认等不是 Provider 配置，不从 Codex 配置自动迁移。
+
+## 旧配置和自定义端点
+
+配置位于当前 Pi agent 目录的 `string-ai.json`，不包含 Key。修改后 `/reload`。旧文件中的 **`models: []` 是明确限制，不会自动被覆盖**；若只是旧教程模板，删除这个字段，或显式开启参考模板：
+
+```json
+{
+  "version": 1,
+  "useBuiltinOpenAIModels": true
+}
+```
+
+不要用此例覆盖自己的其他设置。保留 `models` 而不启用参考模板时，只使用显式档案。
+
+已确认的备用地址是 `https://ai.qpcmqam.cn/v1`，仅手动切换，不自动跨域重发。使用时在 `string-ai.json` 同时设置 `baseUrl` 为该地址和 `useBuiltinOpenAIModels: true`；不填写 Key，修改后 `/reload`、`/string-ai-refresh`。默认主地址保持不变。
+
+若停在 `/model` 面板，先按 `Esc` 回主输入框再输入命令；面板内输入会作为模型搜索文字。
+
+其他自定义端点示例：
+
+```json
+{
+  "version": 1,
+  "baseUrl": "https://api.example.invalid/v1",
+  "useBuiltinOpenAIModels": true,
+  "timeoutMs": 10000
+}
+```
+
+`example.invalid` 是不可用示例，必须换成你明确选择的端点；它不是 String AI 地址。自定义端点默认不启用参考模板，需显式选择。远程端点必须 HTTPS；测试回环 HTTP 另需 `allowInsecureLocalhost: true`。插件不验证自定义服务的实际能力或信任度。
+
+完整显式档案 `models` 支持：`id`、`name`、`contextWindow`、`maxTokens`、`reasoning`、`input`、`cost`（四项每百万 token 费用）、`evidence`。资料须有来源，未知费用不能填零冒充免费。显式档案中的原始 ID 不重命名、不纠正，重复 ID 拒绝。
+
+## 故障提示
+
+- **401**：Key 无效、过期或撤销；重新登录，不输出 Key。
+- **403**：检查分组、协议、模型或第三方客户端权限；不伪装 Codex 绕过。
+- **429**：检查限流、并发和额度，不跨 Key 或协议重试。
+- **无可用模型**：区分服务返回空目录与缺能力档案；查看 `/string-ai-status`。
+- **服务/网络/超时**：诊断不回显原始服务错误体；同身份旧目录可标为过期，但不算新刷新成功。
+- **离线模式**：`PI_OFFLINE` 只要存在（包括空字符串、`0`）便阻止手动刷新。恢复联网需移除变量。
+- **Windows 找不到 Bash**：这是 Pi 工具环境问题；在当前 PowerShell 将实际 Git `bin` 目录加到 PATH。本机示例 `$env:Path = 'D:\Git\bin;' + $env:Path`，不要在其他机器照抄路径。
+
+## 安全和兼容边界
+
+- 固定 Responses HTTP/SSE；宿主默认 `auto` 选择 SSE，显式 WebSocket 拒绝。不静默跨协议、模型或 Key 重发。
+- 经插件自身的请求路径校验最终 `model`、`stream:true`、`store:false`；`store:false` **不等于服务无日志或 Pi 不保存会话**。
+- Provider 禁用内部重试，但 Pi agent 层、其他扩展和手工重试是另一层；限额测试可在自己的设置中禁用 agent 重试，不能声称全局零重复计费。
+- 模型目录只在内存中保存，不从磁盘恢复；换 Key/端点隔离目录，401/403 清除可用性。重启离线没有模型可选。
+- **原版 Pi 1.4.0 的 SEC-01 限制仍存在**：同名 `models.json` 覆盖可能导致宿主全局 adapter 绕过插件检查。不要为 `string-ai` 再叠加模型、端点或协议覆盖；高级配置使用插件自身配置。插件不是其他扩展或用户代码的安全沙箱，服务端仍须校验 Key/分组/模型/额度。
+- 本地宿主补丁是研究设施，不要求普通用户安装，也不宣称上游问题已解决。历史184项通过属于补丁运行时，不代表官方 Pi 全量安全测试全绿。
+- `/logout` 不撤销服务端 Key；环境变量 `STRING_AI_API_KEY` 仍可能认证。卸载不清除其他 Provider 的凭据，也不代为撤销 Key。
+
+卸载此固定版本（以 `pi list` 显示的来源为准）：
+
+```sh
+pi remove npm:pi-provider-string-ai@0.1.0-beta.1
+```
+
+固定版本不会自动升级；升级或回退时显式安装目标版本。跟随 `@beta` 渠道时，使用 `pi update npm:pi-provider-string-ai@beta`，然后 `/reload` 或重启。Pi 1.4.0 的裸 `pi update` 更新宿主，不是只更新插件。
+
+## 开发验证和模拟演示
+
+项目开发依赖锁定 Pi 1.4.0。真实服务、官方宿主、打包安装、npm 分发分别验收，不互相替代。设置专用 `TMPDIR` 后：
+
+```sh
+npm run check
+npm run lint
+npm test
+npm run test:integration
+npm run verify:package
+```
+
+原版宿主全量测试保留 SEC-01 已知失败，不能跳过后称全绿；查看本轮记录中的基线差异。打包验证检查实际 npm pack 产物，包含 env/login × 显式/参考模板闭环，均用回环模拟，无真实 Key。
+
+仅看固定模拟演示：`npm run demo` → `/demo-run` → `/exit`。这是真实文件工具搭配固定模拟模型，不是上述真实使用入口。`npm run test:local` 使用隔离补丁宿主，仅作研究回归。
+
+源码工作区说明（不随 npm 包分发）：
+
+以下是本地源码路径，不是 npm 包内链接；上面的接入步骤在包内 README 中已完整提供。
+
+- `docs/官方Pi使用指南.md`
+- `docs/用户接入改进记录.md`
+- `docs/真实联调与发布待确认清单.md`
+- `docs/本地体验指南.md`
+- `docs/独立安全审查记录.md`
+
+## 发布
+
+本包的发布配置固定为公共 npm Registry、`public` 可见性和 `beta` 标签。许可证暂保留 `UNLICENSED`，不宣称采用开源许可证。公开 tarball 包含 Provider 源码；GitHub 仓库私有不改变 npm 产物的公开性。
+
+`0.1.0-beta.1` 只用于受控测试，不作为真实服务和全部宿主边界已验收的声明。正式稳定版需完成真实模型、权限、费用、升级/回退验收及已知风险处理。开发脚本、测试和研究材料不包含在 npm tarball 中。

package/package.json

@@ -1,6 +1,58 @@
 {
   "name": "pi-provider-string-ai",
-  "version": "0.0.0-stage",
-  "stub": true,
-  "description": "Temporary package placeholder for staged publishing"
-}
+  "version": "0.1.0-beta.1",
+  "private": false,
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/priestwanderer/pi-provider-string-ai.git"
+  },
+  "publishConfig": {
+    "registry": "https://registry.npmjs.org/",
+    "access": "public",
+    "tag": "beta"
+  },
+  "type": "module",
+  "description": "String AI Responses provider extension for Pi",
+  "license": "UNLICENSED",
+  "engines": {
+    "node": ">=22.19.0"
+  },
+  "keywords": [
+    "pi-package",
+    "string-ai",
+    "provider"
+  ],
+  "files": [
+    "src",
+    "README.md",
+    "CHANGELOG.md"
+  ],
+  "pi": {
+    "extensions": [
+      "./src/index.ts"
+    ]
+  },
+  "peerDependencies": {
+    "@earendil-works/pi-ai": "*",
+    "@earendil-works/pi-coding-agent": "*"
+  },
+  "devDependencies": {
+    "@biomejs/biome": "2.6.2",
+    "@earendil-works/pi-ai": "1.4.0",
+    "@earendil-works/pi-coding-agent": "1.4.0",
+    "@types/node": "22.20.5",
+    "tsx": "4.23.15",
+    "typescript": "7.0.2"
+  },
+  "scripts": {
+    "demo": "node scripts/local-demo.mjs",
+    "demo:smoke": "node scripts/local-demo.mjs --smoke",
+    "test:local": "node scripts/run-local-tests.mjs",
+    "check": "tsc --noEmit",
+    "lint": "biome lint src",
+    "verify:package": "node scripts/verify-package.mjs",
+    "test": "node --import tsx --test tests/*.test.ts",
+    "test:integration": "node --import tsx --test tests/integration/*.test.ts",
+    "validate:docs": "python scripts/validate-docs.py"
+  }
+}

package/src/catalog.ts

@@ -0,0 +1,191 @@
+import { normalizeBaseUrl } from './config.js';
+
+type CatalogErrorCode =
+  | 'auth'
+  | 'permission'
+  | 'rate_limit'
+  | 'server'
+  | 'http'
+  | 'timeout'
+  | 'cancelled'
+  | 'network'
+  | 'invalid_catalog'
+  | 'too_large';
+
+export class CatalogError extends Error {
+  code: CatalogErrorCode;
+  status?: number;
+
+  constructor(code: CatalogErrorCode, status?: number) {
+    super(`String AI 模型发现失败（${code}）。`);
+    this.name = 'CatalogError';
+    this.code = code;
+    this.status = status;
+  }
+}
+
+export function parseCatalog(raw: unknown): { id: string; name?: string }[] {
+  if (
+    raw === null ||
+    typeof raw !== 'object' ||
+    Array.isArray(raw) ||
+    !Object.hasOwn(raw, 'data') ||
+    !('data' in raw) ||
+    !Array.isArray(raw.data)
+  )
+    throw new CatalogError('invalid_catalog');
+  if (raw.data.length > 1000) throw new CatalogError('too_large');
+  const result: { id: string; name?: string }[] = [];
+  const seen = new Set<string>();
+  for (const item of raw.data) {
+    if (
+      item === null ||
+      typeof item !== 'object' ||
+      Array.isArray(item) ||
+      !Object.hasOwn(item, 'id') ||
+      typeof item.id !== 'string' ||
+      item.id.length === 0 ||
+      item.id.length > 256 ||
+      item.id.trim() !== item.id ||
+      /[\u0000-\u001f\u007f-\u009f]/u.test(item.id)
+    )
+      throw new CatalogError('invalid_catalog');
+    if (seen.has(item.id)) continue;
+    seen.add(item.id);
+    const name = Object.hasOwn(item, 'display_name') ? item.display_name : undefined;
+    const validName =
+      typeof name === 'string' &&
+      name.length > 0 &&
+      name.trim() === name &&
+      !/[\u0000-\u001f\u007f-\u009f]/u.test(name);
+    result.push(validName ? { id: item.id, name } : { id: item.id });
+  }
+  return result;
+}
+
+export async function discoverModels(options: {
+  baseUrl: string;
+  apiKey: string;
+  signal: AbortSignal;
+  timeoutMs: number;
+  fetch?: typeof globalThis.fetch;
+}): Promise<{ id: string; name?: string }[]> {
+  if (options.signal.aborted) throw new CatalogError('cancelled');
+  const controller = new AbortController();
+  let abortCode: 'cancelled' | 'timeout' | undefined;
+  const abort = (code: 'cancelled' | 'timeout') => {
+    if (abortCode !== undefined) return;
+    abortCode = code;
+    controller.abort();
+  };
+  const onAbort = () => abort('cancelled');
+  options.signal.addEventListener('abort', onAbort, { once: true });
+  const timer = setTimeout(() => abort('timeout'), options.timeoutMs);
+  try {
+    // HTTP 回环地址由配置层的显式开关授权；此处仍拒绝非回环 HTTP。
+    const baseUrl = normalizeBaseUrl(options.baseUrl, true);
+    const pendingResponse = (options.fetch ?? globalThis.fetch)(`${baseUrl}/models`, {
+      method: 'GET',
+      redirect: 'error',
+      signal: controller.signal,
+      headers: { Authorization: `Bearer ${options.apiKey}` },
+    });
+    // 注入的 fetch 可能不遵守信号；晚到结果不能继续提交或持有连接。
+    void pendingResponse.then(
+      (response) => {
+        if (controller.signal.aborted) void response.body?.cancel().catch(() => {});
+      },
+      () => {},
+    );
+    const response = await abortable(pendingResponse, controller.signal);
+    if (!response.ok) {
+      const status = response.status;
+      const code =
+        status === 401
+          ? 'auth'
+          : status === 403
+            ? 'permission'
+            : status === 429
+              ? 'rate_limit'
+              : status >= 500 && status <= 599
+                ? 'server'
+                : 'http';
+      void response.body?.cancel().catch(() => {});
+      throw new CatalogError(code, status);
+    }
+    const length = response.headers.get('content-length');
+    if (length !== null && /^\d+$/.test(length) && Number(length) > 1024 * 1024) {
+      void response.body?.cancel().catch(() => {});
+      throw new CatalogError('too_large');
+    }
+    let raw: unknown;
+    const text = await readBody(response, controller.signal);
+    try {
+      raw = JSON.parse(text);
+    } catch {
+      throw new CatalogError('invalid_catalog');
+    }
+    return parseCatalog(raw);
+  } catch (error) {
+    if (abortCode !== undefined) throw new CatalogError(abortCode);
+    if (error instanceof CatalogError) throw new CatalogError(error.code, error.status);
+    throw new CatalogError('network');
+  } finally {
+    clearTimeout(timer);
+    options.signal.removeEventListener('abort', onAbort);
+  }
+}
+
+async function readBody(response: Response, signal: AbortSignal): Promise<string> {
+  if (response.body === null) throw new CatalogError('invalid_catalog');
+  const reader = response.body.getReader();
+  const chunks: Uint8Array[] = [];
+  let bytes = 0;
+  try {
+    while (true) {
+      const chunk = await abortable(reader.read(), signal);
+      if (chunk.done) break;
+      bytes += chunk.value.byteLength;
+      if (bytes > 1024 * 1024) {
+        void reader.cancel().catch(() => {});
+        throw new CatalogError('too_large');
+      }
+      chunks.push(chunk.value);
+    }
+  } catch (error) {
+    void reader.cancel().catch(() => {});
+    throw error;
+  } finally {
+    reader.releaseLock();
+  }
+  try {
+    return new TextDecoder('utf-8', { fatal: true }).decode(Buffer.concat(chunks, bytes));
+  } catch {
+    throw new CatalogError('invalid_catalog');
+  }
+}
+
+function abortable<T>(pending: Promise<T>, signal: AbortSignal): Promise<T> {
+  return new Promise<T>((resolve, reject) => {
+    const onAbort = () => {
+      signal.removeEventListener('abort', onAbort);
+      reject(new CatalogError('cancelled'));
+    };
+    if (signal.aborted) {
+      void pending.catch(() => {});
+      onAbort();
+      return;
+    }
+    signal.addEventListener('abort', onAbort, { once: true });
+    pending.then(
+      (value) => {
+        signal.removeEventListener('abort', onAbort);
+        resolve(value);
+      },
+      (error: unknown) => {
+        signal.removeEventListener('abort', onAbort);
+        reject(error);
+      },
+    );
+  });
+}

package/src/config.ts

@@ -0,0 +1,208 @@
+import { readFileSync } from 'node:fs';
+import { join } from 'node:path';
+
+export interface ModelProfile {
+  id: string;
+  name: string;
+  contextWindow: number;
+  maxTokens: number;
+  reasoning: boolean;
+  input: ('text' | 'image')[];
+  cost: {
+    input: number;
+    output: number;
+    cacheRead: number;
+    cacheWrite: number;
+  };
+  evidence: string;
+}
+
+export interface StringAiConfig {
+  version: 1;
+  baseUrl?: string;
+  models: ModelProfile[];
+  useBuiltinOpenAIModels?: boolean;
+  allowInsecureLocalhost: boolean;
+  timeoutMs: number;
+}
+
+function invalidConfig(): never {
+  throw new Error('String AI 配置无效，请检查配置格式。');
+}
+
+function object(value: unknown): Record<string, unknown> {
+  if (
+    value === null ||
+    typeof value !== 'object' ||
+    Array.isArray(value) ||
+    ![Object.prototype, null].includes(Object.getPrototypeOf(value))
+  )
+    invalidConfig();
+  return value as Record<string, unknown>;
+}
+
+function knownFields(value: Record<string, unknown>, fields: string[]): void {
+  if (Reflect.ownKeys(value).some((key) => typeof key !== 'string' || !fields.includes(key)))
+    invalidConfig();
+}
+
+export function parseConfig(raw: unknown): StringAiConfig {
+  const value = object(raw);
+  knownFields(value, [
+    'version',
+    'baseUrl',
+    'models',
+    'allowInsecureLocalhost',
+    'timeoutMs',
+    'useBuiltinOpenAIModels',
+  ]);
+  if (value.version !== 1) invalidConfig();
+  const timeoutMs = value.timeoutMs === undefined ? 10000 : value.timeoutMs;
+  const allowInsecureLocalhost =
+    value.allowInsecureLocalhost === undefined ? false : value.allowInsecureLocalhost;
+  if (
+    typeof timeoutMs !== 'number' ||
+    !Number.isInteger(timeoutMs) ||
+    timeoutMs <= 0 ||
+    timeoutMs > 60000
+  )
+    invalidConfig();
+  if (typeof allowInsecureLocalhost !== 'boolean') invalidConfig();
+  // 正式端点由服务方确认；读取默认配置不会自行联网或创建凭据。
+  const baseUrl = normalizeBaseUrl(
+    value.baseUrl === undefined ? 'https://www.string.ink/v1' : (value.baseUrl as string),
+    allowInsecureLocalhost,
+  );
+  // 仅官网默认配置自动启用；显式模型列表（含空列表）保留原有安全门。
+  const useBuiltinOpenAIModels =
+    value.useBuiltinOpenAIModels === undefined
+      ? baseUrl === 'https://www.string.ink/v1' && value.models === undefined
+      : value.useBuiltinOpenAIModels;
+  if (typeof useBuiltinOpenAIModels !== 'boolean') invalidConfig();
+  const models = value.models === undefined ? [] : value.models;
+  if (
+    !Array.isArray(models) ||
+    models.length > 1000 ||
+    (models.length > 0 && baseUrl === undefined)
+  )
+    invalidConfig();
+  const profiles = Array.from(models, parseProfile);
+  if (new Set(profiles.map((profile) => profile.id)).size !== profiles.length) invalidConfig();
+  return {
+    version: 1,
+    baseUrl,
+    models: profiles,
+    useBuiltinOpenAIModels,
+    allowInsecureLocalhost,
+    timeoutMs,
+  };
+}
+
+export function normalizeBaseUrl(value: string, allowInsecureLocalhost = false): string {
+  // 先检查原始文本，不能让 URL 自动修复越界路径或模糊主机。
+  if (typeof value !== 'string' || /[\s\u0000-\u001f\u007f-\u009f\\%?#@]/u.test(value))
+    invalidConfig();
+  const parts = /^(https?):\/\/([A-Za-z0-9.-]+|\[[A-Fa-f0-9:]+\])(?::([0-9]+))?(\/.*)?$/.exec(
+    value,
+  );
+  if (!parts) invalidConfig();
+  const [, protocol, host, port, path = ''] = parts;
+  if (path.split('/').some((segment) => segment === '.' || segment === '..')) invalidConfig();
+  let url: URL;
+  try {
+    url = new URL(value);
+  } catch {
+    invalidConfig();
+  }
+  if (url.hostname.toLowerCase() !== host.toLowerCase() || url.pathname !== (path || '/'))
+    invalidConfig();
+  if (port && String(Number(port)) !== port) invalidConfig();
+  if (
+    protocol === 'http' &&
+    (!allowInsecureLocalhost || !['localhost', '127.0.0.1', '[::1]'].includes(url.hostname))
+  )
+    invalidConfig();
+  const base = `${url.origin}${path}`.replace(/\/+$/, '');
+  return base.endsWith('/v1') ? base : `${base}/v1`;
+}
+
+function parseProfile(raw: unknown): ModelProfile {
+  const value = object(raw);
+  const fields = [
+    'id',
+    'name',
+    'contextWindow',
+    'maxTokens',
+    'reasoning',
+    'input',
+    'cost',
+    'evidence',
+  ];
+  knownFields(value, fields);
+  if (fields.some((field) => !Object.hasOwn(value, field))) invalidConfig();
+  if (
+    typeof value.id !== 'string' ||
+    value.id.length === 0 ||
+    value.id.length > 256 ||
+    value.id.trim() !== value.id ||
+    /[\u0000-\u001f\u007f-\u009f]/u.test(value.id)
+  )
+    invalidConfig();
+  if (
+    typeof value.contextWindow !== 'number' ||
+    !Number.isSafeInteger(value.contextWindow) ||
+    value.contextWindow <= 0
+  )
+    invalidConfig();
+  if (
+    typeof value.maxTokens !== 'number' ||
+    !Number.isSafeInteger(value.maxTokens) ||
+    value.maxTokens <= 0 ||
+    value.maxTokens > value.contextWindow
+  )
+    invalidConfig();
+  const cost = object(value.cost);
+  const costFields = ['input', 'output', 'cacheRead', 'cacheWrite'];
+  knownFields(cost, costFields);
+  if (
+    costFields.some(
+      (key) =>
+        !Object.hasOwn(cost, key) ||
+        typeof cost[key] !== 'number' ||
+        !Number.isFinite(cost[key]) ||
+        (cost[key] as number) < 0,
+    )
+  )
+    invalidConfig();
+  if (
+    !Array.isArray(value.input) ||
+    !value.input.includes('text') ||
+    Array.from(value.input).some((item) => item !== 'text' && item !== 'image') ||
+    new Set(value.input).size !== value.input.length
+  )
+    invalidConfig();
+  if (
+    typeof value.name !== 'string' ||
+    value.name.trim().length === 0 ||
+    typeof value.evidence !== 'string' ||
+    value.evidence.trim().length === 0 ||
+    typeof value.reasoning !== 'boolean'
+  )
+    invalidConfig();
+  return value as unknown as ModelProfile;
+}
+
+export function loadConfig(agentDir: string): StringAiConfig {
+  let content: Buffer;
+  try {
+    content = readFileSync(join(agentDir, 'string-ai.json'));
+  } catch (error) {
+    if ((error as NodeJS.ErrnoException).code === 'ENOENT') return parseConfig({ version: 1 });
+    throw new Error('无法读取 String AI 配置文件。');
+  }
+  try {
+    return parseConfig(JSON.parse(new TextDecoder('utf-8', { fatal: true }).decode(content)));
+  } catch {
+    invalidConfig();
+  }
+}

package/src/index.ts

@@ -0,0 +1,106 @@
+import { getAgentDir, type ExtensionAPI } from '@earendil-works/pi-coding-agent';
+import { CatalogError } from './catalog.js';
+import { loadConfig } from './config.js';
+import { createStringAiProvider } from './provider.js';
+
+/** 只展示固定诊断文本，不回显服务响应、凭据或任意错误正文。 */
+function catalogErrorDescription(code?: string): string {
+  switch (code) {
+    case 'auth':
+      return '401 认证失败，请检查 Key 是否有效，或重新 /login string-ai。';
+    case 'permission':
+      return '403 权限不足，请检查 Key 所绑定分组及其模型权限。';
+    case 'rate_limit':
+      return '429 请求限流，请稍后重试并检查 Key 的使用限制。';
+    case 'server':
+      return '服务暂时不可用，请稍后重试。';
+    case 'timeout':
+      return '请求超时，请检查网络后重试。';
+    case 'cancelled':
+      return '刷新已取消。';
+    case 'network':
+      return '网络连接失败，请检查连接与端点设置。';
+    case 'invalid_catalog':
+      return '模型目录格式无效，请联系服务方确认接口。';
+    case 'too_large':
+      return '模型目录响应过大，请联系服务方确认接口。';
+    case 'http':
+      return 'HTTP 请求失败，请检查端点设置或稍后重试。';
+    default:
+      return '刷新失败，请检查认证、网络与模型配置。';
+  }
+}
+
+function refreshErrorDescription(error: unknown): string {
+  return catalogErrorDescription(error instanceof CatalogError ? error.code : undefined);
+}
+
+/** 认证与模型刷新交给宿主，加载插件时不自行联网。 */
+export default function stringAiExtension(pi: ExtensionAPI): void {
+  const config = loadConfig(getAgentDir());
+  const provider = createStringAiProvider(config);
+  pi.registerProvider(provider);
+  pi.registerCommand('string-ai-help', {
+    description: '查看 String AI 接入帮助，不发送网络请求',
+    handler: async (_args, ctx) => {
+      ctx.ui.notify([
+        'String AI：在官网 https://www.string.ink 创建普通 API Key，选择支持 Responses 及第三方客户端的分组。',
+        '最短流程：官网创建 Key → /login string-ai → /model。TUI 登录后会自动刷新该 Provider。',
+        'Key 仅在 Pi 原生 /login string-ai 中输入，不要贴到聊天或命令参数。',
+        '默认无需 string-ai.json。旧 models:[] 会保持禁用内置参考模板；可删除仅用于旧模板的 models 字段，或显式开启 useBuiltinOpenAIModels，然后 /reload。插件不会代改用户文件；未知模型仍不注册。',
+        '/logout 移除 Pi 已保存凭据，但不会清除 STRING_AI_API_KEY 环境变量；若仍生效，请从启动环境移除该环境变量并重启 Pi。',
+        'Pi 1.4.0 的 secret prompt 并非真正遮罩；输入时不要录屏或共享终端。Responses 的 store:false 不等于服务端不留日志。',
+        '分组由 Key 决定；插件不另选分组，也不额外传 group。换分组、重新发现或故障诊断时使用 /string-ai-refresh，不是每次登录的必需步骤。',
+      ].join('\n'), 'info');
+    },
+  });
+  pi.registerCommand('string-ai-refresh', {
+    description: '重新获取 String AI 模型列表，不发送推理请求',
+    handler: async (_args, ctx) => {
+      // 与 Pi 的 modelNetworkEnabled 一致：变量存在即离线，包括空字符串。
+      if (!config.baseUrl || process.env.PI_OFFLINE !== undefined) {
+        ctx.ui.notify('String AI：未配置端点或处于离线模式，未发送请求。', 'warning');
+        return;
+      }
+      try {
+        if (!ctx.modelRegistry.getProviderAuthStatus('string-ai').configured) {
+          ctx.ui.notify('String AI：尚未配置认证，请先使用 /login string-ai。', 'warning');
+          return;
+        }
+        const result = await ctx.modelRegistry.refresh({ providers: ['string-ai'], allowNetwork: true, force: true });
+        if (result.aborted) {
+          ctx.ui.notify('String AI：刷新已取消。', 'warning');
+          return;
+        }
+        if (result.errors.has('string-ai')) {
+          ctx.ui.notify(`String AI：${refreshErrorDescription(result.errors.get('string-ai'))}`, 'warning');
+          return;
+        }
+        const status = provider.getStatus();
+        if (status.modelCount === 0) {
+          ctx.ui.notify(status.unknownCount > 0
+            ? `String AI：${status.unknownCount} 个目录模型缺少能力档案，当前没有可用模型。请检查模板设置或补充有来源的档案。`
+            : 'String AI：当前没有可用模型，请检查 Key 分组的模型范围。', 'warning');
+          return;
+        }
+        ctx.ui.notify(`String AI：刷新完成，可用模型 ${status.modelCount}；缺少能力档案 ${status.unknownCount}。使用 /model 选择。`, 'info');
+      } catch (error) {
+        ctx.ui.notify(`String AI：${refreshErrorDescription(error)}`, 'error');
+      }
+    },
+  });
+  pi.registerCommand('string-ai-status', {
+    description: '查看 String AI 配置状态，不发送网络请求',
+    handler: async (_args, ctx) => {
+      const status = provider.getStatus() as ReturnType<typeof provider.getStatus> & { referenceModelCount?: number };
+      const referenceCount = status.referenceModelCount ?? 0;
+      const configured = ctx.modelRegistry.getProviderAuthStatus('string-ai').configured;
+      const authentication = !configured ? '认证未配置' : status.configured ? '认证已解析（不代表服务端验证成功）' : '认证已配置，尚未解析';
+      const available = ctx.modelRegistry.getAvailable().filter((model) => model.provider === 'string-ai');
+      ctx.ui.notify(
+        `String AI：端点${config.baseUrl ? '已配置' : '未配置'}；${authentication}；可用模型 ${available.length}；目录模型 ${status.modelCount}；未知模型 ${status.unknownCount}；Pi参考模板 ${referenceCount}。${referenceCount > 0 ? 'Pi上游参考能力/估算费用，非String分组实际账单。' : ''}${status.stale ? '目录陈旧，请用 /string-ai-refresh 重新确认。' : ''}${status.lastError ? `最近目录错误：${catalogErrorDescription(status.lastError.code)}` : ''}认证使用 /login string-ai，配置修改后使用 /reload。`,
+      status.stale || status.lastError ? 'warning' : 'info',
+      );
+    },
+  });
+}

package/src/provider.ts

@@ -0,0 +1,343 @@
+import {
+  createProvider,
+  envApiKeyAuth,
+  lazyStream,
+  type Provider,
+  type Model,
+  type Api,
+  type Credential,
+  type StreamOptions,
+} from '@earendil-works/pi-ai';
+import { getBuiltinModels } from '@earendil-works/pi-ai/providers/all';
+import { openAIResponsesApi } from '@earendil-works/pi-ai/compat';
+import { normalizeBaseUrl, type StringAiConfig } from './config.js';
+import { CatalogError, discoverModels } from './catalog.js';
+
+/** 最近一次认证解析与目录检查的脱敏快照；不主动读环境或联网。 */
+export interface StringAiStatus {
+  configured: boolean;
+  modelCount: number;
+  referenceModelCount?: number;
+  unknownCount: number;
+  stale: boolean;
+  checkedAt?: number;
+  lastError?: { code: string; status?: number };
+}
+
+export interface StringAiProvider extends Provider<'openai-responses'> {
+  /** 本地宿主在任何组合分发前调用；同步拒绝，不能替代原生 payload 终检。 */
+  validateRequest(model: Model<Api>, options?: StreamOptions): void;
+  getStatus(): StringAiStatus;
+}
+
+/** 复用 Pi 原生认证和 Responses 适配器，不自行转换协议。 */
+export function createStringAiProvider(config: StringAiConfig): StringAiProvider {
+  config = structuredClone(config);
+  if (config.baseUrl)
+    config = {
+      ...config,
+      baseUrl: normalizeBaseUrl(config.baseUrl, config.allowInsecureLocalhost),
+    };
+  let generation = 0;
+  let authGeneration = 0;
+  let resolvedKey: string | undefined;
+  let catalogKey: string | undefined;
+  let endpoint = config.baseUrl;
+  let catalogEndpoint: string | undefined;
+  const visible = () =>
+    Boolean(catalogKey && catalogKey === resolvedKey && catalogEndpoint === endpoint);
+  const allowed = (credential: Credential | undefined) =>
+    visible() &&
+    (credential === undefined ||
+      (credential.type === 'api_key' && (!credential.key || credential.key === catalogKey)));
+  let models: Model<'openai-responses'>[] = [];
+  let hasCatalog = false;
+  let status: Omit<StringAiStatus, 'configured' | 'modelCount'> = {
+    unknownCount: 0,
+    stale: false,
+  };
+  // 环境凭据由宿主AuthContext解析；不能另读process.env破坏测试/浏览器隔离。
+  const nativeAuth = envApiKeyAuth('String AI API Key', ['STRING_AI_API_KEY']);
+  const apiKey = {
+    ...nativeAuth,
+    login: async (interaction: Parameters<NonNullable<typeof nativeAuth.login>>[0]) => {
+      interaction.signal.throwIfAborted();
+      interaction.notify({
+        type: 'info',
+        message:
+          '请在 String 官网创建普通 API Key 时选择支持 Responses 和第三方客户端的分组；Pi 无需再传 group。Pi参考模型能力与费用仅为兼容参考，非 String 能力确认或 String 账单。Pi 1.4 的 secret 输入是非遮罩输入，请不要录屏或共享终端。',
+      });
+      // 提示后仍调用原生登录；凭据持久化与取消语义由 Pi 管理。
+      if (!nativeAuth.login) throw new Error('String AI 原生 API Key 登录不可用。');
+      return nativeAuth.login(interaction);
+    },
+    resolve: async (input: Parameters<typeof nativeAuth.resolve>[0]) => {
+      const ticket = ++authGeneration;
+      const result = await nativeAuth.resolve(input);
+      if (ticket === authGeneration) {
+        if (resolvedKey !== result?.auth.apiKey) {
+          generation++;
+          // 身份变化即销毁旧目录，不能切回旧身份后复活先前的授权快照。
+          models = [];
+          hasCatalog = false;
+          catalogKey = undefined;
+          catalogEndpoint = undefined;
+          status = { unknownCount: 0, stale: false };
+        }
+        resolvedKey = result?.auth.apiKey;
+      }
+      return result;
+    },
+  };
+  const knownModel = (model: {
+    id: string;
+    api: string;
+    provider: string;
+    baseUrl: string;
+    type?: string;
+  }) =>
+    (model.type === undefined || model.type === 'chat') &&
+    model.api === 'openai-responses' &&
+    model.provider === 'string-ai' &&
+    model.baseUrl === catalogEndpoint &&
+    models.some((item) => item.id === model.id);
+  const assertRequest = (model: Model<Api>, options?: StreamOptions) => {
+    if (options?.transport && !['auto', 'sse'].includes(options.transport))
+      throw new Error('String AI 仅支持 HTTP/SSE。');
+    if (
+      [model.headers, options?.headers].some(
+        (headers) =>
+          headers &&
+          Object.keys(headers).some((name) => name.toLowerCase() === 'authorization'),
+      )
+    ) {
+      throw new Error('String AI 不允许覆盖认证头，请使用原生 API Key 认证。');
+    }
+    if (!visible() || options?.apiKey !== catalogKey || !knownModel(model)) {
+      throw new Error('String AI 尚未确认当前凭据和端点下的模型可用性，请刷新模型目录。');
+    }
+  };
+  // 只包装请求策略；事件、工具调用和SSE转换完全交给Pi原生适配器。
+  const requestOptions = <T extends StreamOptions>(
+    model: Model<Api>,
+    options?: T,
+  ): T & StreamOptions => {
+    const modelId = model.id;
+    const assertPayload = (payload: unknown) => {
+      if (
+        typeof payload !== 'object' ||
+        payload === null ||
+        !('model' in payload) ||
+        payload.model !== modelId ||
+        !('stream' in payload) ||
+        payload.stream !== true ||
+        !('store' in payload) ||
+        payload.store !== false
+      ) {
+        throw new Error(
+          'String AI 最终请求必须保持已确认的模型、stream=true 和 store=false。',
+        );
+      }
+    };
+    return {
+      ...options,
+      transport: 'sse',
+      maxRetries: 0,
+      onPayload: async (payload, requestModel) => {
+        const replacement = await options?.onPayload?.(payload, requestModel);
+        const finalPayload = replacement === undefined ? payload : replacement;
+        assertPayload(finalPayload);
+        return finalPayload;
+      },
+      fetch: (input, init) => {
+        assertRequest(model, options);
+        // 检查原生SDK已经序列化的原文，不再次调用toJSON或改写合法字段。
+        let payload: unknown;
+        try {
+          if (typeof init?.body !== 'string') throw new Error();
+          payload = JSON.parse(init.body);
+        } catch {
+          throw new Error('String AI 最终请求必须是可验证的 JSON。');
+        }
+        assertPayload(payload);
+        return (options?.fetch ?? globalThis.fetch)(input, {
+          ...init,
+          redirect: 'error',
+        });
+      },
+    } as T & StreamOptions;
+  };
+  // Pi 1.4.0 的扩展加载器对未知子路径按根入口别名展开；使用其显式支持的入口。
+  const responses = openAIResponsesApi();
+  const provider = createProvider<'openai-responses'>({
+    id: 'string-ai',
+    name: 'String AI',
+    baseUrl: config.baseUrl,
+    auth: { apiKey },
+    models: [],
+    api: {
+      stream: (model, context, options) =>
+        lazyStream(model, async () => {
+          assertRequest(model, options);
+          return responses.stream(model, context, requestOptions(model, options));
+        }),
+      streamSimple: (model, context, options) =>
+        lazyStream(model, async () => {
+          assertRequest(model, options);
+          return responses.streamSimple(model, context, requestOptions(model, options));
+        }),
+    },
+  });
+  return {
+    ...provider,
+    validateRequest: assertRequest,
+    getModels: () => (visible() ? structuredClone(models) : []),
+    getAllModels: () => (visible() ? structuredClone(models) : []),
+    filterModels: (items, credential) => (allowed(credential) ? items.filter(knownModel) : []),
+    filterAllModels: (items, credential) =>
+      allowed(credential) ? items.filter(knownModel) : [],
+    getStatus: () => ({
+      configured: Boolean(endpoint && resolvedKey),
+      modelCount: visible() ? models.length : 0,
+      ...(config.useBuiltinOpenAIModels
+        ? {
+            referenceModelCount: visible()
+              ? models.filter(
+                  (model) => !config.models.some((profile) => profile.id === model.id),
+                ).length
+              : 0,
+          }
+        : {}),
+      ...(visible() ? structuredClone(status) : { unknownCount: 0, stale: false }),
+    }),
+    refreshModels: async (context) => {
+      // 不读取stored，也不提供persist：授权目录仅限本实例内存。
+      // 原生publish与本地代次双重检查，覆盖宿主刷新及直接并发调用。
+      const ticket = ++generation;
+      const publish = async (update: () => void) => {
+        let applied = false;
+        const accepted = await context.publish({
+          update: () => {
+            if (ticket !== generation || context.signal.aborted) return;
+            update();
+            applied = true;
+          },
+        });
+        return accepted && applied && ticket === generation && !context.signal.aborted;
+      };
+      const key = context.credential?.type === 'api_key' ? context.credential.key : undefined;
+      const requestedUrl = context.baseUrl ?? config.baseUrl;
+      const baseUrl = requestedUrl
+        ? normalizeBaseUrl(requestedUrl, config.allowInsecureLocalhost)
+        : undefined;
+      if (
+        !(await publish(() => {
+          endpoint = baseUrl;
+          if (key) {
+            authGeneration++;
+            resolvedKey = key;
+          }
+          if (catalogEndpoint !== baseUrl || (key && catalogKey !== key)) {
+            models = [];
+            hasCatalog = false;
+            status = { unknownCount: 0, stale: false };
+            catalogKey = key;
+            catalogEndpoint = baseUrl;
+          }
+        }))
+      )
+        return;
+      if (!context.allowNetwork || !baseUrl || !key) return;
+      let catalog: Awaited<ReturnType<typeof discoverModels>>;
+      try {
+        catalog = await discoverModels({
+          baseUrl,
+          apiKey: key,
+          signal: context.signal,
+          timeoutMs: config.timeoutMs,
+        });
+      } catch (error) {
+        const failure = error instanceof CatalogError ? error : new CatalogError('network');
+        await publish(() => {
+          const revoked = failure.code === 'auth' || failure.code === 'permission';
+          if (revoked) {
+            models = [];
+            hasCatalog = false;
+          }
+          status = {
+            ...status,
+            unknownCount: revoked ? 0 : status.unknownCount,
+            stale: hasCatalog,
+            lastError: {
+              code: failure.code,
+              ...(failure.status === undefined ? {} : { status: failure.status }),
+            },
+          };
+        });
+        throw failure;
+      }
+      const profiles = new Map(config.models.map((profile) => [profile.id, profile]));
+      const discovered: Model<'openai-responses'>[] = catalog.flatMap(({ id }) => {
+        const profile = profiles.get(id);
+        if (!profile) {
+          if (!config.useBuiltinOpenAIModels) return [];
+          // 仅按服务目录原始 ID 精确匹配；这是 Pi 参考，不是 String 能力确认。
+          const reference = getBuiltinModels('openai').find(
+            (item) =>
+              item.id === id &&
+              item.api === 'openai-responses' &&
+              (item.type === undefined || item.type === 'chat'),
+          );
+          if (!reference) return [];
+          // 白名单复制，不能继承官方端点、认证、采样及代理未承诺的 compat/cache 行为。
+          const {
+            name,
+            contextWindow,
+            maxTokens,
+            reasoning,
+            input,
+            cost,
+            thinkingLevelMap,
+            inputLimits,
+          } = reference;
+          return [
+            structuredClone({
+              id,
+              name: `${name}（Pi参考）`,
+              contextWindow,
+              maxTokens,
+              reasoning,
+              input,
+              cost,
+              ...(thinkingLevelMap === undefined ? {} : { thinkingLevelMap }),
+              ...(inputLimits === undefined ? {} : { inputLimits }),
+              api: 'openai-responses' as const,
+              provider: 'string-ai',
+              baseUrl,
+            }),
+          ];
+        }
+        const { evidence: _evidence, ...capabilities } = profile;
+        return [
+          {
+            ...capabilities,
+            api: 'openai-responses' as const,
+            provider: 'string-ai',
+            baseUrl,
+          },
+        ];
+      });
+      await publish(() => {
+        catalogKey = key;
+        catalogEndpoint = baseUrl;
+        models = discovered;
+        hasCatalog = true;
+        status = {
+          unknownCount: catalog.length - discovered.length,
+          stale: false,
+          checkedAt: Date.now(),
+        };
+      });
+    },
+  };
+}