@agent-phonon/protocol 0.2.0

package/src/schemas/document.ts

@@ -0,0 +1,121 @@
+import { z } from "zod";
+import { SessionId, Timestamp } from "./common.js";
+
+/**
+ * 文档交换协议（design 平面③ / D20）。
+ *
+ * 场景：agent 需要/被要求发送本地文档时，在输出里 emit 一个**指令**（skill 教的格式，
+ * 见 DocumentDirective），phonon 解析后**负责读取本地文件**，打包成附件/其他形式发到服务端。
+ * 也就是说：agent 只说「路径」，读盘 + 传输由 phonon 这一层兜。
+ *
+ * 两个层次要分清：
+ *   - DocumentDirective ：agent ↔ phonon 的指令（含本地 path，skill 教）
+ *   - document.send     ：phonon ↔ server 的线协议（含真实内容/附件）
+ */
+
+/** 文档用途/形式。 */
+export const DocumentKind = z.enum([
+  "attachment", // 通用附件
+  "document", // 富文本文档（如 .md → 服务端可转云文档）
+  "image", // 图片
+  "file", // 其他普通文件
+]);
+export type DocumentKind = z.infer<typeof DocumentKind>;
+
+/** 内容承载方式：小文件内联，大文件用 ref 走分块传输（具体待定）。 */
+export const DocumentContent = z.union([
+  z.object({ encoding: z.literal("base64"), data: z.string() }),
+  z.object({ encoding: z.literal("utf8"), data: z.string() }),
+  z.object({ ref: z.string() }), // 分块传输句柄（大文件，开放问题）
+]);
+export type DocumentContent = z.infer<typeof DocumentContent>;
+
+/**
+ * agent 在输出里 emit 的指令格式（skill 教）——只含本地路径与元信息，
+ * phonon 据此读本地文件。**不直接进线协议。**
+ *
+ * 安全（D27 policy）：默认 **project-scoped**——路径必须在绑定项目/worktree 目录内，
+ * 越界需 tenant policy 显式 `allowExternalDocuments`；命中 denyPathPatterns 一律拒。
+ */
+export const DocumentDirective = z.object({
+  /** 文件路径（默认相对于项目/worktree 根；绝对路径需 policy 允许且在范围内）。 */
+  path: z.string().min(1),
+  /** 可选：覆盖文件名（默认取 path 的 basename）。 */
+  name: z.string().optional(),
+  kind: DocumentKind.optional(),
+  caption: z.string().optional(),
+});
+export type DocumentDirective = z.infer<typeof DocumentDirective>;
+
+/** 单个文档的线上描述（phonon 读完本地文件后封装）。 */
+export const DocumentDescriptor = z.object({
+  name: z.string().min(1),
+  /** 相对项目根的路径（审计/去重用；不暴露设备绝对路径）。 */
+  relativePath: z.string().optional(),
+  mimeType: z.string().optional(),
+  kind: DocumentKind.default("file"),
+  caption: z.string().optional(),
+  sizeBytes: z.number().int().nonnegative().optional(),
+  /** 内容 sha256（完整性校验 / 去重）。 */
+  sha256: z.string().optional(),
+  content: DocumentContent,
+});
+export type DocumentDescriptor = z.infer<typeof DocumentDescriptor>;
+
+// --- document.send（phonon → server）---
+export const DocumentSendParams = z.object({
+  /** 关联会话（通常有；纯设备级发送可省）。 */
+  sessionId: SessionId.optional(),
+  /** 关联轮次（若在某轮对话内触发）。 */
+  turnId: z.string().optional(),
+  documents: z.array(DocumentDescriptor).min(1),
+  at: Timestamp,
+});
+export type DocumentSendParams = z.infer<typeof DocumentSendParams>;
+
+export const DocumentSendResult = z.object({
+  delivered: z.array(
+    z.object({
+      name: z.string(),
+      ok: z.boolean(),
+      /** 服务端落地引用（如云文档 token / 附件 id）。 */
+      serverRef: z.string().optional(),
+      error: z.string().optional(),
+    }),
+  ),
+});
+export type DocumentSendResult = z.infer<typeof DocumentSendResult>;
+
+// ===========================================================================
+// 大文件：凭证上传（P1-6 / Gemini#2）
+// 不走 WS 发文件主体（避免内存暴涨/断线重传痛），而是：
+//   phonon → document.prepare_upload {filename,size,mime,sha256}
+//   server → 返回一个 HTTP 上传地址（预签名 URL / 一次性 token）
+//   phonon 本地跑标准 HTTP POST（multipart/流式/断点续传）
+//   上传成功后用 document.send 用 ref 关联回 session
+// ===========================================================================
+export const DocumentPrepareUploadParams = z.object({
+  sessionId: SessionId.optional(),
+  turnId: z.string().optional(),
+  filename: z.string().min(1),
+  sizeBytes: z.number().int().nonnegative(),
+  mimeType: z.string().optional(),
+  sha256: z.string().optional(),
+  kind: DocumentKind.default("file"),
+  at: Timestamp,
+});
+export type DocumentPrepareUploadParams = z.infer<typeof DocumentPrepareUploadParams>;
+
+export const DocumentPrepareUploadResult = z.object({
+  /** 上传句柄，上传成功后回填到 DocumentContent.ref。 */
+  uploadRef: z.string(),
+  /** server 给的 HTTP 上传地址（预签名 URL 等）。 */
+  uploadUrl: z.string(),
+  /** HTTP 方法（默认 PUT）。 */
+  method: z.enum(["PUT", "POST"]).default("PUT"),
+  /** 需携带的额外请求头。 */
+  headers: z.record(z.string()).optional(),
+  /** 上传地址过期时间。 */
+  expiresAt: Timestamp.optional(),
+});
+export type DocumentPrepareUploadResult = z.infer<typeof DocumentPrepareUploadResult>;

package/src/schemas/env.ts

@@ -0,0 +1,60 @@
+import { z } from "zod";
+import { ProjectId, AgentId } from "./common.js";
+
+/** Skill / agent 执行环境变量配置。明文存储在设备本地，list 默认脱敏。 */
+export const EnvScope = z.enum(["global", "project", "skill"]);
+export type EnvScope = z.infer<typeof EnvScope>;
+
+const EnvTargetBase = z.object({
+  scope: EnvScope,
+  projectId: ProjectId.optional(),
+  agent: AgentId.optional(),
+  skillName: z.string().min(1).optional(),
+});
+
+function withEnvTargetRefine<T extends z.ZodTypeAny>(schema: T): T {
+  return schema
+    .refine((v: unknown) => (v as { scope?: string; projectId?: string }).scope !== "project" || !!(v as { projectId?: string }).projectId, { message: "project scope requires projectId", path: ["projectId"] })
+    .refine((v: unknown) => {
+      const x = v as { scope?: string; projectId?: string; agent?: string; skillName?: string };
+      return x.scope !== "skill" || (!!x.projectId && !!x.agent && !!x.skillName);
+    }, { message: "skill scope requires projectId+agent+skillName", path: ["skillName"] }) as unknown as T;
+}
+
+export const EnvTarget = withEnvTargetRefine(EnvTargetBase);
+export type EnvTarget = z.infer<typeof EnvTargetBase>;
+
+export const EnvVarDescriptor = withEnvTargetRefine(EnvTargetBase.extend({
+  name: z.string().min(1),
+  value: z.string().optional(),
+  redacted: z.boolean().default(true),
+  updatedAt: z.string().datetime({ offset: true }).optional(),
+}));
+export type EnvVarDescriptor = z.infer<typeof EnvVarDescriptor>;
+
+export const EnvSetParams = withEnvTargetRefine(EnvTargetBase.extend({
+  clientRequestId: z.string().optional(),
+  name: z.string().min(1),
+  value: z.string(),
+  /** 可选：如果是 secret，list 默认永远脱敏。默认 true。 */
+  secret: z.boolean().default(true),
+}));
+export type EnvSetParams = z.infer<typeof EnvSetParams>;
+export const EnvSetResult = z.object({ variable: EnvVarDescriptor });
+export type EnvSetResult = z.infer<typeof EnvSetResult>;
+
+export const EnvListParams = EnvTargetBase.partial().extend({
+  /** 默认 false；true 需要本地 policy allowEnvReveal。 */
+  reveal: z.boolean().default(false),
+});
+export type EnvListParams = z.infer<typeof EnvListParams>;
+export const EnvListResult = z.object({ variables: z.array(EnvVarDescriptor) });
+export type EnvListResult = z.infer<typeof EnvListResult>;
+
+export const EnvDeleteParams = withEnvTargetRefine(EnvTargetBase.extend({
+  clientRequestId: z.string().optional(),
+  name: z.string().min(1),
+}));
+export type EnvDeleteParams = z.infer<typeof EnvDeleteParams>;
+export const EnvDeleteResult = z.object({ deleted: z.literal(true), name: z.string() });
+export type EnvDeleteResult = z.infer<typeof EnvDeleteResult>;

package/src/schemas/file.ts

@@ -0,0 +1,97 @@
+import { z } from "zod";
+import { ProjectId } from "./common.js";
+
+/**
+ * 受控工作区文件读写协议。
+ *
+ * 与 document.send 不同：document.send 是 agent 主动把产物发给 server；
+ * file.* 是 server 主动读写本地 project/worktree 内文件。
+ */
+
+export const FileEncoding = z.enum(["utf8", "base64"]);
+export type FileEncoding = z.infer<typeof FileEncoding>;
+
+export const FileScope = z.object({
+  projectId: ProjectId,
+  /** 可选：指定 worktree；缺省为项目主目录。 */
+  worktreeId: z.string().min(1).optional(),
+});
+export type FileScope = z.infer<typeof FileScope>;
+
+const RelativePath = z.string().min(1).refine((p) => !p.startsWith("/") && !p.includes("\0"), {
+  message: "path must be a relative path",
+});
+
+export const FileStat = z.object({
+  path: z.string(),
+  type: z.enum(["file", "directory", "symlink", "other"]),
+  sizeBytes: z.number().nonnegative(),
+  modifiedAt: z.string().datetime({ offset: true }).optional(),
+});
+export type FileStat = z.infer<typeof FileStat>;
+
+export const FileReadParams = FileScope.extend({
+  path: RelativePath,
+  encoding: FileEncoding.default("utf8"),
+  /** 可选：最大读取字节数，避免误读超大文件。 */
+  maxBytes: z.number().int().positive().optional(),
+});
+export type FileReadParams = z.infer<typeof FileReadParams>;
+
+export const FileReadResult = z.object({
+  path: z.string(),
+  encoding: FileEncoding,
+  data: z.string(),
+  sizeBytes: z.number().nonnegative(),
+  truncated: z.boolean().default(false),
+});
+export type FileReadResult = z.infer<typeof FileReadResult>;
+
+export const FileWriteParams = FileScope.extend({
+  /** 可选：幂等键。 */
+  clientRequestId: z.string().optional(),
+  path: RelativePath,
+  encoding: FileEncoding.default("utf8"),
+  data: z.string(),
+  /** 缺省 true；false 时若文件已存在则报错。 */
+  overwrite: z.boolean().default(true),
+  /** 是否自动创建父目录。 */
+  createDirs: z.boolean().default(true),
+});
+export type FileWriteParams = z.infer<typeof FileWriteParams>;
+
+export const FileWriteResult = z.object({
+  path: z.string(),
+  sizeBytes: z.number().nonnegative(),
+  written: z.literal(true),
+});
+export type FileWriteResult = z.infer<typeof FileWriteResult>;
+
+export const FileListParams = FileScope.extend({
+  path: RelativePath.default("."),
+  recursive: z.boolean().default(false),
+  limit: z.number().int().positive().max(10000).default(500),
+});
+export type FileListParams = z.infer<typeof FileListParams>;
+
+export const FileListResult = z.object({
+  path: z.string(),
+  entries: z.array(FileStat),
+  truncated: z.boolean().default(false),
+});
+export type FileListResult = z.infer<typeof FileListResult>;
+
+export const FileStatParams = FileScope.extend({ path: RelativePath });
+export type FileStatParams = z.infer<typeof FileStatParams>;
+export const FileStatResult = z.object({ stat: FileStat });
+export type FileStatResult = z.infer<typeof FileStatResult>;
+
+export const FileMkdirParams = FileScope.extend({
+  /** 可选：幂等键。 */
+  clientRequestId: z.string().optional(),
+  path: RelativePath,
+  recursive: z.boolean().default(true),
+});
+export type FileMkdirParams = z.infer<typeof FileMkdirParams>;
+export const FileMkdirResult = z.object({ path: z.string(), created: z.literal(true) });
+export type FileMkdirResult = z.infer<typeof FileMkdirResult>;

package/src/schemas/hook.ts

@@ -0,0 +1,66 @@
+import { z } from "zod";
+import { SessionId, Timestamp } from "./common.js";
+import { HookType } from "./capabilities.js";
+import { ContextItem } from "./session.js";
+
+/**
+ * Hook / 人在回路 HITL（design §8）。
+ *
+ * 核心：phonon 自己不实现人在回路，只做事件中转 + 阻塞等裁决。
+ *   phonon → server : hook.fired   （到 hook 点抛事件）
+ *   server → phonon : hook.resolve （裁决；服务端决定是否问真人、怎么问、等多久）
+ */
+
+/** hook 触发载荷（phonon → server）。 */
+export const HookFiredParams = z.object({
+  sessionId: SessionId,
+  /** 本次 hook 的唯一 id，hook.resolve 用它配对。 */
+  hookId: z.string().min(1),
+  hookType: HookType,
+  /** 触发上下文：被拦截的操作详情（命令、工具名、参数、文件路径等）。 */
+  payload: z
+    .object({
+      toolName: z.string().optional(),
+      command: z.string().optional(),
+      filePath: z.string().optional(),
+      url: z.string().optional(),
+      /** 其余 adapter 特定字段。 */
+      extra: z.record(z.unknown()).optional(),
+    })
+    .default({}),
+  /** 该 turn 的关联 id（若在某轮对话内触发）。 */
+  turnId: z.string().optional(),
+  at: Timestamp,
+});
+export type HookFiredParams = z.infer<typeof HookFiredParams>;
+
+/**
+ * 裁决动作（server → phonon）。
+ * - continue : 放行，照常执行
+ * - inject   : 先注入上下文再继续（用 context 字段）
+ * - modify   : 用修改后的参数继续（用 patch 字段，如改写命令）
+ * - abort    : 中止该操作（可带原因）
+ */
+export const HookAction = z.enum(["continue", "inject", "modify", "abort"]);
+export type HookAction = z.infer<typeof HookAction>;
+
+export const HookResolveParams = z.object({
+  sessionId: SessionId,
+  /** 必须与对应 hook.fired 的 hookId 一致。 */
+  hookId: z.string().min(1),
+  action: HookAction,
+  /** action=inject 时：要注入的上下文。 */
+  context: z.array(ContextItem).optional(),
+  /** action=modify 时：对被拦截操作的修改（结构与该 hook 的 payload 对应）。 */
+  patch: z.record(z.unknown()).optional(),
+  /** action=abort 时：可选原因，会回传给 agent / 记录。 */
+  reason: z.string().optional(),
+});
+export type HookResolveParams = z.infer<typeof HookResolveParams>;
+
+export const HookResolveResult = z.object({
+  sessionId: SessionId,
+  hookId: z.string(),
+  applied: z.boolean(),
+});
+export type HookResolveResult = z.infer<typeof HookResolveResult>;

package/src/schemas/interaction.ts

@@ -0,0 +1,135 @@
+import { z } from "zod";
+import { SessionId, Timestamp } from "./common.js";
+
+/**
+ * 人机交互协议（design 平面③ / D21）。
+ *
+ * 场景：HITL 时、或 agent 主动想问人，发一个**可交互卡片/表单**（抽象结构），
+ * phonon → server 渲染给人（飞书卡片/网页/TG 按钮…由服务端决定，复用「甩锅服务端」原则），
+ * 人填完 → 原路返回 → 注入回 agent。
+ *
+ * 两个层次：
+ *   - InteractionDirective ：agent emit 的表单定义（skill 教，让任何模型都能发）
+ *   - interaction.request   ：phonon → server 线协议（带 requestId，阻塞等回填）
+ *   - interaction.response  ：server → phonon 线协议（人填完的值）
+ *
+ * 表单只定义**抽象字段结构**，不绑定任何渲染方式——服务端自由渲染。
+ */
+
+/** 字段类型（抽象，渲染由服务端决定）。 */
+export const FieldType = z.enum([
+  "text", // 单行文本
+  "textarea", // 多行文本
+  "number",
+  "boolean", // 开关/勾选
+  "select", // 单选
+  "multiselect", // 多选
+  "date",
+]);
+export type FieldType = z.infer<typeof FieldType>;
+
+export const FormFieldOption = z.object({
+  label: z.string(),
+  value: z.string(),
+});
+export type FormFieldOption = z.infer<typeof FormFieldOption>;
+
+/**
+ * 表单字段——按 type 的 discriminated union（P2-16）。
+ * 每种类型携自己的 defaultValue 类型与专属字段，避免「select 该传 string 还是 string[]」的歧义。
+ */
+const FieldBase = { key: z.string().min(1), label: z.string().min(1), required: z.boolean().default(false), help: z.string().optional() };
+
+export const FormField = z.discriminatedUnion("type", [
+  z.object({ ...FieldBase, type: z.literal("text"), placeholder: z.string().optional(), defaultValue: z.string().optional() }),
+  z.object({ ...FieldBase, type: z.literal("textarea"), placeholder: z.string().optional(), defaultValue: z.string().optional() }),
+  z.object({ ...FieldBase, type: z.literal("number"), defaultValue: z.number().optional() }),
+  z.object({ ...FieldBase, type: z.literal("boolean"), defaultValue: z.boolean().optional() }),
+  z.object({ ...FieldBase, type: z.literal("select"), options: z.array(FormFieldOption), defaultValue: z.string().optional() }),
+  z.object({ ...FieldBase, type: z.literal("multiselect"), options: z.array(FormFieldOption), defaultValue: z.array(z.string()).optional() }),
+  z.object({ ...FieldBase, type: z.literal("date"), defaultValue: z.string().optional() }),
+]);
+export type FormField = z.infer<typeof FormField>;
+
+/** 表单/卡片定义（抽象）。 */
+export const InteractionForm = z.object({
+  title: z.string().min(1),
+  /** 卡片正文/说明（可选）。 */
+  description: z.string().optional(),
+  fields: z.array(FormField).default([]),
+  /** 提交/操作按钮；纯通知类可只放一个「知道了」。 */
+  submitLabel: z.string().default("提交"),
+  cancelLabel: z.string().optional(),
+});
+export type InteractionForm = z.infer<typeof InteractionForm>;
+
+/**
+ * agent emit 的指令（skill 教）——和 interaction.request 结构基本一致，
+ * 但不带 requestId（由 phonon 生成）。
+ */
+export const InteractionDirective = z.object({
+  form: InteractionForm,
+  /** 是否阻塞等待人回填（true=问答；false=纯通知不等）。 */
+  blocking: z.boolean().default(true),
+  /** 关联 hookId（若由 HITL hook 触发，便于和 hook.resolve 合流）。 */
+  hookId: z.string().optional(),
+});
+export type InteractionDirective = z.infer<typeof InteractionDirective>;
+
+// --- interaction.request（phonon → server）---
+export const InteractionRequestParams = z.object({
+  /** 本次交互唯一 id，response 用它配对。 */
+  requestId: z.string().min(1),
+  sessionId: SessionId.optional(),
+  turnId: z.string().optional(),
+  form: InteractionForm,
+  blocking: z.boolean().default(true),
+  /** 关联 hookId（HITL 场景）。 */
+  hookId: z.string().optional(),
+  /**
+   * 可选超时（秒，P1-5）。超时后 phonon 以 timeout 收尾本次交互，agent 按预设继续。
+   * 0 或缺省 = 不超时（人可能去开会/带娃，长期挂起）。
+   */
+  timeoutSeconds: z.number().int().nonnegative().optional(),
+  at: Timestamp,
+});
+export type InteractionRequestParams = z.infer<typeof InteractionRequestParams>;
+
+/** 人机交互的生命周期状态（P1-5）：pending → submitted | cancelled | timeout。 */
+export const InteractionStatus = z.enum(["pending", "submitted", "cancelled", "timeout"]);
+export type InteractionStatus = z.infer<typeof InteractionStatus>;
+
+/** 阻塞模式下，request 的最终结果（人填完后服务端回的）。 */
+export const InteractionRequestResult = z.object({
+  requestId: z.string(),
+  /** 结果状态：submit | cancel | timeout。 */
+  action: z.enum(["submit", "cancel", "timeout"]),
+  /** 提交时各字段值（key → 值）。 */
+  values: z.record(z.union([z.string(), z.array(z.string()), z.boolean(), z.number()])).optional(),
+});
+export type InteractionRequestResult = z.infer<typeof InteractionRequestResult>;
+
+// --- interaction.cancel（server → phonon 或 phonon 内部）：主动取消一个 pending 交互 ---
+export const InteractionCancelParams = z.object({
+  requestId: z.string().min(1),
+  reason: z.string().optional(),
+});
+export type InteractionCancelParams = z.infer<typeof InteractionCancelParams>;
+
+export const InteractionCancelResult = z.object({
+  requestId: z.string(),
+  cancelled: z.boolean(),
+});
+export type InteractionCancelResult = z.infer<typeof InteractionCancelResult>;
+
+/**
+ * server → phonon 的回填（非阻塞模式或异步回填走这个 notification；
+ * 阻塞模式可直接用 interaction.request 的 result 返回，二选一，实现可都支持）。
+ */
+export const InteractionResponseParams = z.object({
+  requestId: z.string().min(1),
+  action: z.enum(["submit", "cancel", "timeout"]),
+  values: z.record(z.union([z.string(), z.array(z.string()), z.boolean(), z.number()])).optional(),
+  at: Timestamp,
+});
+export type InteractionResponseParams = z.infer<typeof InteractionResponseParams>;

package/src/schemas/jsonrpc.ts

@@ -0,0 +1,80 @@
+import { z } from "zod";
+import { PhononErrorData } from "./common.js";
+
+/**
+ * JSON-RPC 2.0 信封（design D2）。
+ *
+ * 单条 WebSocket 上双向跑 JSON-RPC 2.0：两端皆可作 requester。
+ * - server → phonon：session.* / discovery.* / hook.resolve
+ * - phonon → server：stream.event / hook.fired / discovery.changed / connect.hello
+ *
+ * 这里只定义「信封」的通用形状；具体方法的 params/result 由 methods.ts 绑定。
+ */
+
+export const JsonRpcVersion = z.literal("2.0");
+
+/** 请求 id：字符串或数字（JSON-RPC 允许两者；notification 无 id）。 */
+export const JsonRpcId = z.union([z.string(), z.number()]);
+export type JsonRpcId = z.infer<typeof JsonRpcId>;
+
+/** 请求（需要响应）。 */
+export const JsonRpcRequest = z.object({
+  jsonrpc: JsonRpcVersion,
+  id: JsonRpcId,
+  method: z.string(),
+  params: z.unknown().optional(),
+});
+export type JsonRpcRequest = z.infer<typeof JsonRpcRequest>;
+
+/** 通知（不需要响应，无 id）——用于 stream.event / hook.fired / discovery.changed。 */
+export const JsonRpcNotification = z.object({
+  jsonrpc: JsonRpcVersion,
+  method: z.string(),
+  params: z.unknown().optional(),
+});
+export type JsonRpcNotification = z.infer<typeof JsonRpcNotification>;
+
+/** 成功响应。 */
+export const JsonRpcSuccess = z.object({
+  jsonrpc: JsonRpcVersion,
+  id: JsonRpcId,
+  result: z.unknown(),
+});
+export type JsonRpcSuccess = z.infer<typeof JsonRpcSuccess>;
+
+/** JSON-RPC error 对象；data 携带 phonon 应用级错误结构。 */
+export const JsonRpcErrorObject = z.object({
+  /** JSON-RPC 传输级 code（-32700..-32600 保留；应用错误用 data.appCode 判别）。 */
+  code: z.number().int(),
+  message: z.string(),
+  data: PhononErrorData.optional(),
+});
+export type JsonRpcErrorObject = z.infer<typeof JsonRpcErrorObject>;
+
+/** 失败响应。 */
+export const JsonRpcError = z.object({
+  jsonrpc: JsonRpcVersion,
+  id: JsonRpcId.nullable(),
+  error: JsonRpcErrorObject,
+});
+export type JsonRpcError = z.infer<typeof JsonRpcError>;
+
+/** 任意一条 JSON-RPC 报文。 */
+export const JsonRpcMessage = z.union([
+  JsonRpcRequest,
+  JsonRpcNotification,
+  JsonRpcSuccess,
+  JsonRpcError,
+]);
+export type JsonRpcMessage = z.infer<typeof JsonRpcMessage>;
+
+/** 标准 JSON-RPC 传输级错误码。 */
+export const JSON_RPC_CODES = {
+  parseError: -32700,
+  invalidRequest: -32600,
+  methodNotFound: -32601,
+  invalidParams: -32602,
+  internalError: -32603,
+  /** 应用级错误统一用这个 code，细分看 data.appCode。 */
+  applicationError: -32000,
+} as const;