pennyrouter 0.2.9 → 0.2.10

package/src/launch.test.js

@@ -1,153 +1,170 @@
-import assert from "node:assert/strict";
-import fs from "node:fs";
-import os from "node:os";
-import path from "node:path";
-
-import {
-  buildPennyInvocation,
-  claudeLaunchSettingsPath,
-  claudeUserSkillPath,
-  codexLaunchProfilePath,
-  configurePennyHarness,
-  fileMode,
-  installPennyRuntime,
-  loadPennyConfig,
-  pennyConfigPath,
-  pennyRuntimeDir,
-  pennyShimPath,
-  removePennyHarness,
-  removePennyRuntime,
-  renderCodexLaunchProfile,
-} from "./launch.js";
-
-const ENV_KEYS = [
-  "HOME", "XDG_CONFIG_HOME", "XDG_DATA_HOME", "XDG_STATE_HOME", "CODEX_HOME", "PATH", "SHELL",
-];
-
-async function main() {
-  if (!(["darwin", "linux"].includes(process.platform))) {
-    console.log("launch.test.js: skipped on unsupported platform");
-    return;
-  }
-
-  const root = fs.mkdtempSync(path.join(os.tmpdir(), "pr-launch-test-"));
-  const previous = Object.fromEntries(ENV_KEYS.map((key) => [key, process.env[key]]));
-  const home = path.join(root, "home");
-  fs.mkdirSync(path.join(home, ".claude"), { recursive: true });
-  fs.mkdirSync(path.join(home, ".codex"), { recursive: true });
-  const nativeClaude = `${JSON.stringify({
-    permissions: { allow: ["Read"] },
-    statusLine: { type: "command", command: "native-status" },
-  }, null, 2)}\n`;
-  const nativeCodex = 'model = "native-model"\n';
-  fs.writeFileSync(path.join(home, ".claude", "settings.json"), nativeClaude);
-  fs.writeFileSync(path.join(home, ".codex", "config.toml"), nativeCodex);
-  fs.writeFileSync(path.join(home, ".zshrc"), "# user setting\n");
-
-  Object.assign(process.env, {
-    HOME: home,
-    XDG_CONFIG_HOME: path.join(home, ".config"),
-    XDG_DATA_HOME: path.join(home, ".local", "share"),
-    XDG_STATE_HOME: path.join(home, ".local", "state"),
-    CODEX_HOME: path.join(home, ".codex"),
-    PATH: "/usr/bin:/bin",
-    SHELL: "/bin/zsh",
-  });
-
-  try {
-    const first = await installPennyRuntime();
-    const staleSkill = path.join(pennyRuntimeDir(), "claude-plugin", "skills", "penny", "SKILL.md");
-    fs.mkdirSync(path.dirname(staleSkill), { recursive: true });
-    fs.writeFileSync(staleSkill, "stale plugin file");
-    const second = await installPennyRuntime();
-    assert.equal(first.supported, true);
-    assert.equal(first.changed, true);
-    assert.equal(second.changed, false);
-    assert.equal(await fileMode(pennyShimPath()), 0o755);
-    assert.ok(fs.existsSync(path.join(pennyRuntimeDir(), "bin", "penny.js")));
-    assert.ok(!fs.existsSync(staleSkill), "runtime upgrade removes stale plugin files");
-    const rc = fs.readFileSync(path.join(home, ".zshrc"), "utf8");
-    assert.equal((rc.match(/>>> pennyrouter PATH >>>/g) || []).length, 1);
-
-    await configurePennyHarness("claude-code", {
-      apiKey: "pr-super-secret",
-      gatewayBaseUrl: "https://gateway.example/",
-      subscriptionAuth: true,
-      models: { haiku: "Haiku 4.5 (PennyRouter)", sonnet: "Sonnet 5 (PennyRouter)", opus: "Opus 5 (PennyRouter)" },
-    });
-    await configurePennyHarness("codex", {
-      apiKey: "pr-super-secret",
-      gatewayBaseUrl: "https://gateway.example/",
-      subscriptionAuth: true,
-    });
-
-    assert.equal(fs.readFileSync(path.join(home, ".claude", "settings.json"), "utf8"), nativeClaude);
-    assert.equal(fs.readFileSync(path.join(home, ".codex", "config.toml"), "utf8"), nativeCodex);
-    assert.equal(await fileMode(pennyConfigPath()), 0o600);
-    assert.equal(await fileMode(claudeLaunchSettingsPath()), 0o600);
-    assert.equal(await fileMode(codexLaunchProfilePath()), 0o600);
-
-    const config = await loadPennyConfig();
-    assert.equal(config.api_key, "pr-super-secret");
-    const codexProfile = fs.readFileSync(codexLaunchProfilePath(), "utf8");
-    assert.ok(codexProfile.includes('env_http_headers = { "x-pennyrouter-key" = "PENNYROUTER_API_KEY" }'));
-    assert.ok(!codexProfile.includes("pr-super-secret"));
-    assert.ok(!rc.includes("pr-super-secret"));
-
-    const claude = buildPennyInvocation("claude", ["--resume", "abc"], config);
-    assert.equal(claude.command, "claude");
-    assert.deepEqual(claude.args.slice(-2), ["--resume", "abc"]);
-    assert.ok(!claude.args.includes("--plugin-dir"));
-    assert.equal(claude.env.ANTHROPIC_AUTH_TOKEN, "pr-super-secret");
-    assert.equal(claude.env.ANTHROPIC_BASE_URL, "https://gateway.example/");
-    assert.equal(claude.env.ANTHROPIC_DEFAULT_OPUS_MODEL, "Opus 5 (PennyRouter)");
-
-    const codex = buildPennyInvocation("codex", ["resume", "--last"], config);
-    assert.deepEqual(codex.args, ["--profile", "pennyrouter", "resume", "--last"]);
-    assert.equal(codex.env.PENNYROUTER_API_KEY, "pr-super-secret");
-    assert.throws(() => buildPennyInvocation("claude", ["--settings=x"], config), /manages --settings/);
-    assert.throws(() => buildPennyInvocation("codex", ["-p", "other"], config), /manages --profile/);
-
-    const command = fs.readFileSync(claudeUserSkillPath(), "utf8");
-    assert.ok(command.includes("@penny $ARGUMENTS"));
-    assert.ok(command.includes("name: penny"));
-
-    await removePennyHarness("claude-code");
-    assert.ok(!fs.existsSync(claudeUserSkillPath()));
-    fs.mkdirSync(path.dirname(claudeUserSkillPath()), { recursive: true });
-    fs.writeFileSync(claudeUserSkillPath(), "user-owned command\n");
-    await assert.rejects(configurePennyHarness("claude-code", {
-      apiKey: "pr-super-secret",
-      gatewayBaseUrl: "https://gateway.example/",
-      models: {},
-    }), /not managed by PennyRouter/);
-    assert.equal(fs.readFileSync(claudeUserSkillPath(), "utf8"), "user-owned command\n");
-    assert.ok(fs.existsSync(codexLaunchProfilePath()));
-    assert.ok(fs.existsSync(pennyShimPath()));
-    await removePennyHarness("codex");
-    await removePennyRuntime();
-    assert.ok(!fs.existsSync(pennyShimPath()));
-    assert.ok(!fs.existsSync(pennyRuntimeDir()));
-    assert.ok(!fs.existsSync(pennyConfigPath()));
-    assert.equal(fs.readFileSync(path.join(home, ".zshrc"), "utf8"), "# user setting\n");
-
-    const paid = renderCodexLaunchProfile({
-      gatewayBaseUrl: "https://gateway.example/", subscriptionAuth: false,
-    });
-    assert.ok(paid.includes('env_key = "PENNYROUTER_API_KEY"'));
-    assert.ok(!paid.includes("requires_openai_auth"));
-  } finally {
-    for (const key of ENV_KEYS) {
-      if (previous[key] === undefined) delete process.env[key];
-      else process.env[key] = previous[key];
-    }
-    fs.rmSync(root, { recursive: true, force: true });
-  }
-
-  console.log("launch.test.js: all checks passed");
-}
-
-main().catch((error) => {
-  console.error(error);
-  process.exit(1);
-});
+import assert from "node:assert/strict";
+import fs from "node:fs";
+import os from "node:os";
+import path from "node:path";
+
+import {
+  buildPennyInvocation,
+  claudeLaunchSettingsPath,
+  claudeUserSkillPath,
+  codexLaunchProfilePath,
+  configurePennyHarness,
+  fileMode,
+  installPennyRuntime,
+  loadPennyConfig,
+  pennyConfigPath,
+  pennyRuntimeDir,
+  pennyShimPath,
+  removePennyHarness,
+  removePennyRuntime,
+  renderCodexLaunchProfile,
+} from "./launch.js";
+import { claudeCodeHarness } from "./harnesses/claude-code.js";
+
+const ENV_KEYS = [
+  "HOME", "XDG_CONFIG_HOME", "XDG_DATA_HOME", "XDG_STATE_HOME", "CODEX_HOME", "PATH", "SHELL",
+];
+
+async function main() {
+  if (!(["darwin", "linux"].includes(process.platform))) {
+    console.log("launch.test.js: skipped on unsupported platform");
+    return;
+  }
+
+  const root = fs.mkdtempSync(path.join(os.tmpdir(), "pr-launch-test-"));
+  const previous = Object.fromEntries(ENV_KEYS.map((key) => [key, process.env[key]]));
+  const home = path.join(root, "home");
+  fs.mkdirSync(path.join(home, ".claude"), { recursive: true });
+  fs.mkdirSync(path.join(home, ".codex"), { recursive: true });
+  const nativeClaude = `${JSON.stringify({
+    permissions: { allow: ["Read"] },
+    statusLine: { type: "command", command: "native-status" },
+  }, null, 2)}\n`;
+  const nativeCodex = 'model = "native-model"\n';
+  fs.writeFileSync(path.join(home, ".claude", "settings.json"), nativeClaude);
+  fs.writeFileSync(path.join(home, ".codex", "config.toml"), nativeCodex);
+  fs.writeFileSync(path.join(home, ".zshrc"), "# user setting\n");
+
+  Object.assign(process.env, {
+    HOME: home,
+    XDG_CONFIG_HOME: path.join(home, ".config"),
+    XDG_DATA_HOME: path.join(home, ".local", "share"),
+    XDG_STATE_HOME: path.join(home, ".local", "state"),
+    CODEX_HOME: path.join(home, ".codex"),
+    PATH: "/usr/bin:/bin",
+    SHELL: "/bin/zsh",
+  });
+
+  try {
+    const first = await installPennyRuntime();
+    const staleSkill = path.join(pennyRuntimeDir(), "claude-plugin", "skills", "penny", "SKILL.md");
+    fs.mkdirSync(path.dirname(staleSkill), { recursive: true });
+    fs.writeFileSync(staleSkill, "stale plugin file");
+    const second = await installPennyRuntime();
+    assert.equal(first.supported, true);
+    assert.equal(first.changed, true);
+    assert.equal(second.changed, false);
+    assert.equal(await fileMode(pennyShimPath()), 0o755);
+    assert.ok(fs.existsSync(path.join(pennyRuntimeDir(), "bin", "penny.js")));
+    assert.ok(!fs.existsSync(staleSkill), "runtime upgrade removes stale plugin files");
+    const rc = fs.readFileSync(path.join(home, ".zshrc"), "utf8");
+    assert.equal((rc.match(/>>> pennyrouter PATH >>>/g) || []).length, 1);
+
+    await configurePennyHarness("claude-code", {
+      apiKey: "pr-super-secret",
+      gatewayBaseUrl: "https://gateway.example/",
+      subscriptionAuth: true,
+      // Simulate an existing install. `penny claude` must fix this at launch,
+      // without requiring a separate reinstall before its context limits are right.
+      models: { haiku: "Haiku 4.5 (PennyRouter)", sonnet: "Sonnet 5 (PennyRouter)", opus: "Opus 5 (PennyRouter)" },
+    });
+    await configurePennyHarness("codex", {
+      apiKey: "pr-super-secret",
+      gatewayBaseUrl: "https://gateway.example/",
+      subscriptionAuth: true,
+    });
+
+    assert.equal(fs.readFileSync(path.join(home, ".claude", "settings.json"), "utf8"), nativeClaude);
+    assert.equal(fs.readFileSync(path.join(home, ".codex", "config.toml"), "utf8"), nativeCodex);
+    assert.equal(await fileMode(pennyConfigPath()), 0o600);
+    assert.equal(await fileMode(claudeLaunchSettingsPath()), 0o600);
+    assert.equal(await fileMode(codexLaunchProfilePath()), 0o600);
+
+    const config = await loadPennyConfig();
+    assert.equal(config.api_key, "pr-super-secret");
+    const codexProfile = fs.readFileSync(codexLaunchProfilePath(), "utf8");
+    assert.ok(codexProfile.includes('env_http_headers = { "x-pennyrouter-key" = "PENNYROUTER_API_KEY" }'));
+    assert.ok(!codexProfile.includes("pr-super-secret"));
+    assert.ok(!rc.includes("pr-super-secret"));
+
+    const claude = buildPennyInvocation("claude", ["--resume", "abc"], config);
+    assert.equal(claude.command, "claude");
+    assert.deepEqual(claude.args.slice(-2), ["--resume", "abc"]);
+    assert.ok(!claude.args.includes("--plugin-dir"));
+    assert.equal(claude.env.ANTHROPIC_AUTH_TOKEN, "pr-super-secret");
+    assert.equal(claude.env.ANTHROPIC_BASE_URL, "https://gateway.example/");
+    assert.equal(claude.env.ANTHROPIC_DEFAULT_OPUS_MODEL, "claude-opus-5");
+    assert.equal(claude.env.ANTHROPIC_DEFAULT_HAIKU_MODEL, "claude-haiku-4-5-20251001");
+    assert.equal(claude.env.CLAUDE_CODE_MAX_CONTEXT_TOKENS, undefined);
+
+    const codex = buildPennyInvocation("codex", ["resume", "--last"], config);
+    assert.deepEqual(codex.args, ["--profile", "pennyrouter", "resume", "--last"]);
+    assert.equal(codex.env.PENNYROUTER_API_KEY, "pr-super-secret");
+    assert.throws(() => buildPennyInvocation("claude", ["--settings=x"], config), /manages --settings/);
+    assert.throws(() => buildPennyInvocation("codex", ["-p", "other"], config), /manages --profile/);
+
+    const command = fs.readFileSync(claudeUserSkillPath(), "utf8");
+    assert.ok(command.includes("@penny $ARGUMENTS"));
+    assert.ok(command.includes("name: penny"));
+
+    // Persistent direct-Claude installs use the same native ids and must not
+    // leave the former global 1M override behind.
+    await claudeCodeHarness.install({
+      apiKey: "pr-super-secret",
+      gatewayBaseUrl: "https://gateway.example/",
+      plan: { configPath: path.join(home, ".claude", "settings.json") },
+    });
+    const persistedClaude = JSON.parse(fs.readFileSync(path.join(home, ".claude", "settings.json"), "utf8"));
+    assert.equal(persistedClaude.env.ANTHROPIC_DEFAULT_HAIKU_MODEL, "claude-haiku-4-5-20251001");
+    assert.equal(persistedClaude.env.ANTHROPIC_DEFAULT_SONNET_MODEL, "claude-sonnet-5");
+    assert.equal("CLAUDE_CODE_MAX_CONTEXT_TOKENS" in persistedClaude.env, false);
+
+    await removePennyHarness("claude-code");
+    assert.ok(!fs.existsSync(claudeUserSkillPath()));
+    fs.mkdirSync(path.dirname(claudeUserSkillPath()), { recursive: true });
+    fs.writeFileSync(claudeUserSkillPath(), "user-owned command\n");
+    await assert.rejects(configurePennyHarness("claude-code", {
+      apiKey: "pr-super-secret",
+      gatewayBaseUrl: "https://gateway.example/",
+      models: {},
+    }), /not managed by PennyRouter/);
+    assert.equal(fs.readFileSync(claudeUserSkillPath(), "utf8"), "user-owned command\n");
+    assert.ok(fs.existsSync(codexLaunchProfilePath()));
+    assert.ok(fs.existsSync(pennyShimPath()));
+    await removePennyHarness("codex");
+    await removePennyRuntime();
+    assert.ok(!fs.existsSync(pennyShimPath()));
+    assert.ok(!fs.existsSync(pennyRuntimeDir()));
+    assert.ok(!fs.existsSync(pennyConfigPath()));
+    assert.equal(fs.readFileSync(path.join(home, ".zshrc"), "utf8"), "# user setting\n");
+
+    const paid = renderCodexLaunchProfile({
+      gatewayBaseUrl: "https://gateway.example/", subscriptionAuth: false,
+    });
+    assert.ok(paid.includes('env_key = "PENNYROUTER_API_KEY"'));
+    assert.ok(!paid.includes("requires_openai_auth"));
+  } finally {
+    for (const key of ENV_KEYS) {
+      if (previous[key] === undefined) delete process.env[key];
+      else process.env[key] = previous[key];
+    }
+    fs.rmSync(root, { recursive: true, force: true });
+  }
+
+  console.log("launch.test.js: all checks passed");
+}
+
+main().catch((error) => {
+  console.error(error);
+  process.exit(1);
+});

package/src/mcp.js

@@ -0,0 +1,228 @@
+/* PennyRouter MCP server (stdio).
+
+   Solves the last mile: a thread you can read in the browser is not a thread you can code from.
+   These two tools let an agent take a share link and either read it or *become* it.
+
+     thread_read    fetch + parse, return the transcript to the model. For "what did we decide
+                    in this chat?" — the body lands in the caller's context, which is the point.
+     thread_resume  fetch + parse, write a resumable Claude Code session, return only a path and
+                    a one-line summary. For "let's continue coding from this chat" — the
+                    transcript never enters the caller's context, so moving a 200-turn thread
+                    costs the caller nothing. That asymmetry is the whole reason for two tools.
+
+   ALL SCRAPING STAYS SERVER-SIDE. This process holds no adapters, no fetcher credentials and no
+   provider knowledge; it POSTs a URL to the gateway and gets a canonical thread back. What ships
+   to a user's machine is a client, not the machinery.
+
+   Hand-rolled JSON-RPC rather than @modelcontextprotocol/sdk: this package has zero dependencies
+   and is installed by `npx pennyrouter`, where every transitive dep is a supply-chain surface and
+   a slower cold start. The protocol surface actually needed here is four methods. */
+
+import { createInterface } from "node:readline";
+import { execFileSync } from "node:child_process";
+
+import { writeSession, VERIFIED_MIN, VERIFIED_MAX } from "./thread-session.js";
+
+const PROTOCOL_VERSION = "2024-11-05";
+
+const TOOLS = [
+  {
+    name: "thread_read",
+    description:
+      "Fetch an AI conversation from a share link (ChatGPT, Claude, Gemini, Perplexity) and " +
+      "return its transcript. Use when the user wants to discuss, summarize or ask about a " +
+      "past conversation. The transcript enters your context — for long threads that are " +
+      "meant to be continued as work, prefer thread_resume.",
+    inputSchema: {
+      type: "object",
+      properties: {
+        url: { type: "string", description: "The share link to read." },
+      },
+      required: ["url"],
+    },
+  },
+  {
+    name: "thread_resume",
+    description:
+      "Fetch an AI conversation from a share link and write it as a resumable Claude Code " +
+      "session in a workspace, so the user can `claude --resume` into it and continue coding " +
+      "with that conversation as history. Use when the user wants to CONTINUE or BUILD FROM a " +
+      "past chat rather than talk about it. Returns a session id and path; the transcript is " +
+      "deliberately NOT returned, so importing a long thread costs you no context.",
+    inputSchema: {
+      type: "object",
+      properties: {
+        url: { type: "string", description: "The share link to import." },
+        directory: {
+          type: "string",
+          description:
+            "Absolute path to the workspace the session should resume in. Defaults to the " +
+            "current working directory.",
+        },
+      },
+      required: ["url"],
+    },
+  },
+];
+
+function claudeVersion() {
+  try {
+    return execFileSync("claude", ["--version"], { encoding: "utf8" }).trim();
+  } catch {
+    return null;
+  }
+}
+
+async function fetchCanonical(url, { gatewayBaseUrl, apiKey }) {
+  const response = await fetch(`${gatewayBaseUrl}/v1/penny/threads/canonical`, {
+    method: "POST",
+    headers: {
+      "content-type": "application/json",
+      authorization: `Bearer ${apiKey}`,
+    },
+    body: JSON.stringify({ url }),
+  });
+
+  if (!response.ok) {
+    let detail = `HTTP ${response.status}`;
+    try {
+      const body = await response.json();
+      // The gateway's 400s carry copy written for a person; surface it rather than a status.
+      if (body?.detail) detail = body.detail;
+    } catch {
+      /* non-JSON error body; the status is all we have */
+    }
+    throw new Error(detail);
+  }
+  return response.json();
+}
+
+function transcript(thread) {
+  const lines = [`# ${thread.title || "Imported thread"}`];
+  if (thread.source_url) lines.push(`Source: ${thread.source_url}`);
+  lines.push("");
+  for (const message of thread.messages || []) {
+    const body = (message.blocks || [])
+      .map((b) => {
+        if (b.type === "text") return b.text;
+        if (b.type === "file") return ["```" + (b.language || ""), b.text, "```"].join("\n");
+        if (b.type === "thinking") return null;
+        if (b.type === "tool_use") return `[used ${b.name}]`;
+        if (b.type === "tool_result") return `[tool result] ${b.output || ""}`;
+        return null;
+      })
+      .filter((t) => t && String(t).trim())
+      .join("\n\n");
+    if (!body.trim()) continue;
+    lines.push(`## ${message.role}`, body, "");
+  }
+  return lines.join("\n").trim();
+}
+
+async function callTool(name, args, context) {
+  const url = String(args?.url || "").trim();
+  if (!url) throw new Error("a share link is required");
+
+  if (name === "thread_read") {
+    const thread = await fetchCanonical(url, context);
+    return transcript(thread);
+  }
+
+  if (name === "thread_resume") {
+    const cwd = String(args?.directory || process.cwd());
+    const version = claudeVersion();
+    const thread = await fetchCanonical(url, context);
+    const { sessionId, path, messageCount } = writeSession(thread, { cwd, version });
+    return [
+      `Imported "${thread.title}" (${thread.messages?.length || 0} messages, ` +
+        `~${thread.token_estimate || 0} tokens) from ${thread.origin_app || thread.source}.`,
+      "",
+      `Wrote a resumable session: ${messageCount} records`,
+      `  ${path}`,
+      "",
+      "Resume it with:",
+      `  cd ${cwd} && claude --resume ${sessionId}`,
+      "",
+      "The transcript was written to disk and deliberately not returned here, so it did not " +
+        "consume this session's context.",
+    ].join("\n");
+  }
+
+  throw new Error(`unknown tool: ${name}`);
+}
+
+function send(message) {
+  process.stdout.write(JSON.stringify(message) + "\n");
+}
+
+function reply(id, result) {
+  send({ jsonrpc: "2.0", id, result });
+}
+
+/** Tool failures are reported as results with isError, not as JSON-RPC errors: the model should
+    see what went wrong and be able to tell the user, not have the call vanish into the harness. */
+function toolError(id, error) {
+  reply(id, {
+    content: [{ type: "text", text: `Failed: ${error?.message || String(error)}` }],
+    isError: true,
+  });
+}
+
+export async function runMcpServer({ gatewayBaseUrl, apiKey }) {
+  if (!apiKey) {
+    process.stderr.write(
+      "pennyrouter mcp: no API key. Run `npx pennyrouter install` first.\n",
+    );
+    process.exitCode = 1;
+    return;
+  }
+
+  const context = { gatewayBaseUrl, apiKey };
+  const rl = createInterface({ input: process.stdin });
+
+  for await (const line of rl) {
+    if (!line.trim()) continue;
+
+    let request;
+    try {
+      request = JSON.parse(line);
+    } catch {
+      continue; // a malformed frame has no id to answer to
+    }
+
+    const { id, method, params } = request;
+    try {
+      if (method === "initialize") {
+        reply(id, {
+          protocolVersion: PROTOCOL_VERSION,
+          capabilities: { tools: {} },
+          serverInfo: { name: "pennyrouter", version: "1.0.0" },
+        });
+      } else if (method === "tools/list") {
+        reply(id, { tools: TOOLS });
+      } else if (method === "tools/call") {
+        try {
+          const text = await callTool(params?.name, params?.arguments || {}, context);
+          reply(id, { content: [{ type: "text", text }] });
+        } catch (error) {
+          toolError(id, error);
+        }
+      } else if (method === "ping") {
+        reply(id, {});
+      } else if (id !== undefined) {
+        // Notifications (no id) are fire-and-forget and must never be answered.
+        send({ jsonrpc: "2.0", id, error: { code: -32601, message: `unknown method: ${method}` } });
+      }
+    } catch (error) {
+      if (id !== undefined) {
+        send({
+          jsonrpc: "2.0",
+          id,
+          error: { code: -32603, message: error?.message || String(error) },
+        });
+      }
+    }
+  }
+}
+
+export { VERIFIED_MIN, VERIFIED_MAX };