opencode-zen-freex 0.2.0 → 0.2.2

package/capture.mjs

@@ -0,0 +1,203 @@
+// Recaptures fingerprint.json from a real OpenCode.
+//
+// The free tier reads the wording of the tools it knows by name out of the
+// request body and refuses the request when it differs from its own copy. That
+// copy moves with OpenCode, so the one held here goes stale — and a stale copy
+// looks exactly like a working one until somebody is refused. This is how a new
+// one is taken, so that refreshing it is a command and not an archaeology
+// exercise.
+//
+//   bun run capture            # writes fingerprint.json
+//   bun run capture -- --dry   # reports what changed, writes nothing
+//
+// Needs opencode on PATH (https://opencode.ai) and bun. Nothing goes to Zen: the
+// OpenCode under test is pointed at a server running here, and the request it
+// makes is the thing being read.
+
+import { spawn } from "node:child_process";
+import { readFileSync } from "node:fs";
+import { mkdtempSync } from "node:fs";
+import { tmpdir } from "node:os";
+import { join } from "node:path";
+import { PROFILES } from "./core-tools.mjs";
+
+const PORT = Number(process.env.CAPTURE_PORT ?? 8791);
+const DRY = process.argv.includes("--dry");
+const HERE = import.meta.dir;
+const FINGERPRINT = join(HERE, "fingerprint.json");
+
+// The names Zen reads. Everything else a host declares is ignored by it.
+const READ = ["bash", "glob", "grep", "read", "write", "edit"];
+
+// The capture host's own scratch directory and OS banner belong to the machine
+// the capture ran on, not to the tool. These are put back to something neutral
+// so the capture is not tied to one machine.
+const NEUTRALISE = [
+  [/Be aware: OS: [^\n]*/g, "Be aware: OS: linux, Shell: bash"],
+  [/Use `[^`]*` for temporary work outside the workspace\./g, "Use `/tmp` for temporary work outside the workspace."],
+  [/Use `[A-Za-z]:\\[^`]*`/g, "Use `/tmp`"],
+];
+// Zen compares roughly the first 700 characters and ignores the rest; 1200
+// leaves margin, and the tail is where a note to the model goes.
+const KEEP = 1200;
+
+const capturedPath = join(tmpdir(), `zen-capture-${process.pid}.json`);
+const server = Bun.serve({
+  port: PORT,
+  hostname: "127.0.0.1",
+  async fetch(request) {
+    const url = new URL(request.url);
+    if (url.pathname.endsWith("/models"))
+      return Response.json({ object: "list", data: [{ id: "big-pickle", object: "model", owned_by: "opencode" }] });
+    // OpenCode makes more than one request (a short one for the title, then the
+    // real one). The one worth reading is the longest, since it is the one that
+    // carries the full toolset.
+    const body = await request.text();
+    let previous = { agent: null, body: "" };
+    try {
+      previous = JSON.parse(readFileSync(capturedPath, "utf8"));
+    } catch {}
+    if (body.length > previous.body.length)
+      await Bun.write(capturedPath, JSON.stringify({ agent: request.headers.get("user-agent"), body }));
+    return new Response(
+      [
+        'data: {"id":"c1","object":"chat.completion.chunk","created":1,"model":"big-pickle","choices":[{"index":0,"delta":{"role":"assistant","content":"OK"},"finish_reason":null}]}',
+        'data: {"id":"c1","object":"chat.completion.chunk","created":1,"model":"big-pickle","choices":[{"index":0,"delta":{},"finish_reason":"stop"}]}',
+        "data: [DONE]",
+        "",
+      ].join("\n\n"),
+      { headers: { "content-type": "text/event-stream" } },
+    );
+  },
+});
+
+const home = mkdtempSync(join(tmpdir(), "zen-capture-home-"));
+// Where OpenCode looks for its config is XDG_CONFIG_HOME/opencode, and the
+// three XDG directories are pointed at `home` below.
+const config = join(home, "config", "opencode", "opencode.json");
+await Bun.write(
+  config,
+  JSON.stringify({ provider: { opencode: { options: { baseURL: `http://127.0.0.1:${PORT}/v1` } } } }),
+);
+
+console.log(`listening on 127.0.0.1:${PORT}, running opencode against it`);
+let ran = true;
+const code = await new Promise((done) => {
+  const child = spawn("opencode", ["run", "-m", "opencode/big-pickle", "Say OK."], {
+    env: {
+      ...process.env,
+      XDG_DATA_HOME: join(home, "data"),
+      XDG_CONFIG_HOME: join(home, "config"),
+      XDG_CACHE_HOME: join(home, "cache"),
+    },
+    stdio: ["ignore", "ignore", "inherit"],
+  });
+  child.on("error", () => {
+    console.error("could not run opencode; install it from https://opencode.ai and put it on PATH");
+    ran = false;
+    done(1);
+  });
+  child.on("exit", (value) => done(value ?? 0));
+});
+server.stop(true);
+if (!ran) process.exit(1);
+
+let request;
+try {
+  request = JSON.parse(readFileSync(capturedPath, "utf8"));
+} catch {
+  console.error("no request was captured; opencode did not reach the local server");
+  process.exit(1);
+}
+
+const body = JSON.parse(request.body);
+const tools = {};
+for (const raw of body.tools ?? []) {
+  const tool = raw.function ?? raw;
+  if (!tool?.name || !READ.includes(tool.name) || !tool.description) continue;
+  tools[tool.name] = {
+    name: tool.name,
+    description: NEUTRALISE.reduce((text, [find, to]) => text.replace(find, to), tool.description).slice(0, KEEP),
+    parameters: tool.parameters,
+  };
+}
+
+const missing = READ.filter((name) => !tools[name]);
+if (missing.length) {
+  console.error(
+    `the captured request has no ${missing.join(", ")}; this OpenCode no longer sends them, so it cannot be captured this way`,
+  );
+  process.exit(1);
+}
+for (const [name, tool] of Object.entries(tools))
+  if (tool.description.length < 100) {
+    console.error(`${name}'s description looks truncated (${tool.description.length} chars); not writing`);
+    process.exit(1);
+}
+
+// Which generation this client is: the names it sends say so.
+const generation = body.tools.some((t) => (t.function ?? t).name === "shell") ? "2.x" : "1.x";
+const required = generation === "2.x" ? ["shell", "read"] : ["bash", "glob", "grep", "read"];
+const absent = required.filter((name) => !tools[name]);
+if (absent.length) {
+  console.error(`a ${generation} request must carry ${absent.join(", ")}, and the capture does not`);
+  process.exit(1);
+}
+
+// Which protocol was captured, since each of 1.x's protocols bundles its own
+// provider-utils and a capture must not overwrite the ones it did not observe.
+const protocol = body.input !== undefined && body.messages === undefined ? "responses" : "chat";
+
+console.log(`\nagent:  ${request.agent}`);
+console.log(`tools:  ${Object.keys(tools).join(", ")}  (${generation}, ${protocol})`);
+if (code !== 0) console.log(`(opencode exited ${code}; its request was still captured)`);
+
+const agent = parseAgent(request.agent);
+if (agent.providerUtils) agent.providerUtils = { ...PROFILES[generation]?.agent?.providerUtils, [protocol]: agent.providerUtils[protocol] };
+
+const before = PROFILES[generation];
+const agentChanged = JSON.stringify(before?.agent) !== JSON.stringify(agent);
+let changed = 0;
+for (const name of Object.keys(tools)) {
+  if (JSON.stringify(before?.tools?.[name]) !== JSON.stringify(tools[name])) changed++;
+  console.log(`  ${name.padEnd(6)} ${JSON.stringify(before?.tools?.[name]) === JSON.stringify(tools[name]) ? "unchanged" : "CHANGED"}  ${tools[name].description.length} chars`);
+}
+if (agent.providerUtils)
+  console.log(`  agent  ${agentChanged ? "CHANGED" : "unchanged"}  ${protocol} provider-utils kept separate from the others`);
+
+if (DRY) {
+  const what = [changed ? `${changed} tool(s)` : null, agentChanged ? "the agent" : null].filter(Boolean);
+  console.log(`\n${what.length ? `${what.join(" and ")} would change.` : "Nothing would change."} Nothing written (--dry).`);
+  process.exit(what.length ? 1 : 0);
+}
+
+if (!changed && !agentChanged) {
+  console.log("\nnothing changed.");
+  process.exit(0);
+}
+
+const next = JSON.parse(readFileSync(FINGERPRINT, "utf8"));
+next.profiles[generation] = { agent, required, tools };
+await Bun.write(FINGERPRINT, JSON.stringify(next, null, 2) + "\n");
+console.log(`\nwrote ${FINGERPRINT} for ${generation}. Now run \`bun run check:gate\` and commit if it passes.`);
+
+// The User-Agent is stored the way agentFor() reads it back, which is not
+// necessarily the same split the raw header used.
+function parseAgent(agent) {
+  const twoPart = /^opencode\/(\d[^ ]*) ai-sdk\/provider-utils\/(\S+) (\S+)$/.exec(agent ?? "");
+  if (twoPart) {
+    const [, opencode, providerUtils, runtime] = twoPart;
+    return {
+      opencode,
+      providerUtils: { chat: providerUtils, responses: providerUtils, anthropic: providerUtils },
+      runtime,
+    };
+  }
+  const threePart = /^opencode\/([a-z]+)\/(\d[^/]*)\/([a-z-]+)$/.exec(agent ?? "");
+  if (threePart) {
+    const [, channel, opencode, client] = threePart;
+    return { channel, opencode, client };
+  }
+  console.error(`\ncould not read \`${agent}\` as an OpenCode User-Agent; write PROFILES[${generation}].agent by hand`);
+  process.exit(1);
+}

package/core-tools.mjs

@@ -23,9 +23,6 @@ const captured = JSON.parse(readFileSync(new URL("./fingerprint.json", import.me
 
 export const PROFILES = captured.profiles;
 
-/** The names Zen reads the wording of, for a generation. */
-const readNames = (generation) => Object.keys(PROFILES[generation].tools);
-
 /**
  * The generation a request belongs to, told by the tools it carries. Tool names
  * move far less often than descriptions do, so this survives a rewording that a
@@ -49,5 +46,3 @@ export function agentFor(generation, protocol = "chat") {
     ? `opencode/${agent.opencode} ai-sdk/provider-utils/${agent.providerUtils[protocol]} ${agent.runtime}`
     : `opencode/${agent.channel}/${agent.opencode}/${agent.client}`;
 }
-
-export { readNames };

package/index.mjs

@@ -1,3 +1,3 @@
-import plugin from "./provider.mjs"
-
-export const ZenFreePlugin = plugin.server
+import plugin from "./provider.mjs"
+
+export const ZenFreePlugin = plugin.server

package/models.mjs

@@ -1,148 +1,211 @@
-export const PROVIDER = "opencode-zen-free";
-export const SDK = {
-  chat: "@ai-sdk/openai-compatible",
-  responses: "@ai-sdk/openai",
-  anthropic: "@ai-sdk/anthropic",
-};
-
-export function parseProtocolDocs(text) {
-  const protocols = {};
-  const pattern =
-    /\|[^|]+\|\s*`?([^|`\s]+)`?\s*\|\s*`[^`]+\/v1\/(chat\/completions|responses|messages|systemone)`/g;
-  for (const match of text.matchAll(pattern)) {
-    protocols[match[1]] = {
-      "chat/completions": "chat",
-      responses: "responses",
-      messages: "anthropic",
-      systemone: "systemone",
-    }[match[2]];
-  }
-  return protocols;
-}
-
-function sdkProtocol(npm) {
-  if (npm?.includes("anthropic")) return "anthropic";
-  if (npm === SDK.responses) return "responses";
-  if (npm?.includes("openai-compatible")) return "chat";
-}
-
-function isRetired(model) {
-  return (
-    model.deprecated === true ||
-    ["deprecated", "retired", "disabled"].includes(model.status ?? model.lifecycle) ||
-    model.deprecated_at != null ||
-    model.retirement_date != null
-  );
-}
-
-export function isFree(id, model = {}) {
-  return (
-    !isRetired(model) && (/free/i.test(id) || (model.cost?.input === 0 && model.cost?.output === 0))
-  );
-}
-
-export function buildModels(ids, provider, protocols, baseURL) {
-  const result = {};
-  for (const id of ids) {
-    if (typeof id !== "string" || !id || id === "__proto__") continue;
-    const raw = provider.models?.[id];
-    const model = raw ?? {};
-    const protocol = protocols[id] ?? (raw && sdkProtocol(model.provider?.npm ?? provider.npm));
-    if (!isFree(id, model) || !Object.hasOwn(SDK, protocol)) continue;
-    const input = model.modalities?.input ?? ["text"];
-    const output = model.modalities?.output ?? ["text"];
-    const modalities = (values) =>
-      Object.fromEntries(
-        ["text", "image", "audio", "video", "pdf"].map((name) => [name, values.includes(name)]),
-      );
-    const efforts = (model.reasoning_options ?? [])
-      .filter((option) => option.type === "effort")
-      .flatMap((option) => option.values ?? []);
-    result[id] = {
-      id,
-      providerID: PROVIDER,
-      name: model.name ?? id,
-      api: { id, url: baseURL, npm: SDK[protocol] },
-      limit: { context: 32768, output: 4096, ...model.limit },
-      capabilities: {
-        temperature: model.temperature ?? true,
-        reasoning: model.reasoning ?? false,
-        attachment: model.attachment ?? input.some((name) => name !== "text"),
-        toolcall: model.tool_call ?? true,
-        input: modalities(input),
-        output: modalities(output),
-        interleaved: model.interleaved ?? false,
-      },
-      cost: { input: 0, output: 0, cache: { read: 0, write: 0 } },
-      variants: Object.fromEntries(efforts.map((effort) => [effort, { reasoningEffort: effort }])),
-      options: {},
-      headers: {},
-      status: model.status ?? "active",
-      release_date: model.release_date ?? "",
-      free: true,
-    };
-  }
-  return result;
-}
-
-// Offline bootstrap metadata from the OpenCode catalog, 2026-10-06.
-export const bootstrapProvider = {
-  npm: SDK.chat,
-  models: {
-    "big-pickle": {
-      name: "Big Pickle",
-      cost: { input: 0, output: 0 },
-      limit: { context: 200000, input: 160000, output: 32000 },
-      reasoning: true,
-      tool_call: true,
-      interleaved: { field: "reasoning_content" },
-    },
-    "space-bunny-free": {
-      name: "Space Bunny Free",
-      cost: { input: 0, output: 0 },
-      limit: { context: 1048576, input: 524288, output: 524288 },
-      reasoning: true,
-      tool_call: true,
-    },
-    "muse-spark-1.3-contributor-free": {
-      name: "Muse Spark 1.3 Free",
-      cost: { input: 0, output: 0 },
-      provider: { npm: SDK.responses },
-      limit: { context: 1048576, output: 131072 },
-      reasoning: true,
-      tool_call: true,
-      modalities: { input: ["text", "image", "video", "pdf", "audio"], output: ["text"] },
-      reasoning_options: [
-        { type: "effort", values: ["minimal", "low", "medium", "high", "xhigh"] },
-      ],
-    },
-  },
-};
-
-export function configModels(models) {
-  return Object.fromEntries(
-    Object.entries(models).map(([id, model]) => [
-      id,
-      {
-        id,
-        name: model.name,
-        provider: { npm: model.api.npm, api: model.api.url },
-        limit: model.limit,
-        reasoning: model.capabilities.reasoning,
-        tool_call: model.capabilities.toolcall,
-        attachment: model.capabilities.attachment,
-        modalities: {
-          input: Object.keys(model.capabilities.input).filter(
-            (key) => model.capabilities.input[key],
-          ),
-          output: Object.keys(model.capabilities.output).filter(
-            (key) => model.capabilities.output[key],
-          ),
-        },
-        cost: { input: 0, output: 0 },
-        variants: model.variants,
-        free: true,
-      },
-    ]),
-  );
-}
+export const PROVIDER = "opencode-zen-free";
+export const SDK = {
+  chat: "@ai-sdk/openai-compatible",
+  responses: "@ai-sdk/openai",
+  anthropic: "@ai-sdk/anthropic",
+};
+
+export function parseProtocolDocs(text) {
+  const protocols = {};
+  const pattern =
+    /\|[^|]+\|\s*`?([^|`\s]+)`?\s*\|\s*`[^`]+\/v1\/(chat\/completions|responses|messages|systemone)`/g;
+  for (const match of text.matchAll(pattern)) {
+    protocols[match[1]] = {
+      "chat/completions": "chat",
+      responses: "responses",
+      messages: "anthropic",
+      systemone: "systemone",
+    }[match[2]];
+  }
+  return protocols;
+}
+
+function sdkProtocol(npm) {
+  if (npm?.includes("anthropic")) return "anthropic";
+  if (npm === SDK.responses) return "responses";
+  if (npm?.includes("openai-compatible")) return "chat";
+}
+
+function isRetired(model) {
+  return (
+    model.deprecated === true ||
+    ["deprecated", "retired", "disabled"].includes(model.status ?? model.lifecycle) ||
+    model.deprecated_at != null ||
+    model.retirement_date != null
+  );
+}
+
+export function isFree(id, model = {}) {
+  return (
+    !isRetired(model) && (/free/i.test(id) || (model.cost?.input === 0 && model.cost?.output === 0))
+  );
+}
+
+export function buildModels(ids, provider, protocols, baseURL) {
+  const result = {};
+  for (const id of ids) {
+    if (typeof id !== "string" || !id || id === "__proto__") continue;
+    const raw = provider.models?.[id];
+    const model = raw ?? {};
+    const protocol = protocols[id] ?? (raw && sdkProtocol(model.provider?.npm ?? provider.npm));
+    if (!isFree(id, model) || !Object.hasOwn(SDK, protocol)) continue;
+    const input = model.modalities?.input ?? ["text"];
+    const output = model.modalities?.output ?? ["text"];
+    const modalities = (values) =>
+      Object.fromEntries(
+        ["text", "image", "audio", "video", "pdf"].map((name) => [name, values.includes(name)]),
+      );
+    const efforts = (model.reasoning_options ?? [])
+      .filter((option) => option.type === "effort")
+      .flatMap((option) => option.values ?? []);
+    result[id] = {
+      id,
+      providerID: PROVIDER,
+      name: model.name ?? id,
+      api: { id, url: baseURL, npm: SDK[protocol] },
+      limit: { context: 32768, output: 4096, ...model.limit },
+      capabilities: {
+        temperature: model.temperature ?? true,
+        reasoning: model.reasoning ?? false,
+        attachment: model.attachment ?? input.some((name) => name !== "text"),
+        toolcall: model.tool_call ?? true,
+        input: modalities(input),
+        output: modalities(output),
+        interleaved: model.interleaved ?? false,
+      },
+      cost: { input: 0, output: 0, cache: { read: 0, write: 0 } },
+      variants: Object.fromEntries(efforts.map((effort) => [effort, { reasoningEffort: effort }])),
+      options: {},
+      headers: {},
+      status: model.status ?? "active",
+      release_date: model.release_date ?? "",
+      free: true,
+    };
+  }
+  return result;
+}
+
+// What each free model is asked at, from OpenCode's console docs
+// (services/www/src/docs/content/console/models.mdx) on 2026-10-15: used for
+// a listed model when the docs can't be read, so the catalog or the docs
+// being out of reach never leaves a listed free model out. Jev is a
+// SystemOne decision model, not one to chat with.
+export const bootstrapProtocols = {
+  "big-pickle": "chat",
+  "space-bunny-free": "chat",
+  "cat-jam-free": "chat",
+  "longcat-2.5-preview-free": "chat",
+  "step-5-preview-free": "chat",
+  "mimo-v2.6-flash-free": "chat",
+  "nemotron-3.5-lightning-free": "chat",
+  "muse-spark-1.3-contributor-free": "responses",
+  "jev-1.13-free": "systemone",
+};
+
+// Offline bootstrap metadata from the OpenCode catalog, 2026-10-06; the
+// free models listed since added on 2026-10-15.
+export const bootstrapProvider = {
+  npm: SDK.chat,
+  models: {
+    "cat-jam-free": {
+      name: "Cat Jam Free",
+      cost: { input: 0, output: 0 },
+      limit: { context: 262144, output: 131072 },
+      reasoning: true,
+      tool_call: true,
+      interleaved: { field: "reasoning_content" },
+      reasoning_options: [{ type: "effort", values: ["low", "medium", "high", "xhigh", "max"] }],
+    },
+    "step-5-preview-free": {
+      name: "Step 5 Preview Free",
+      cost: { input: 0, output: 0 },
+      limit: { context: 1000000, input: 1000000, output: 65536 },
+      reasoning: true,
+      tool_call: true,
+      interleaved: { field: "reasoning_content" },
+      modalities: { input: ["text", "image", "video"], output: ["text"] },
+      reasoning_options: [{ type: "effort", values: ["low", "medium", "high"] }],
+    },
+    "longcat-2.5-preview-free": {
+      name: "LongCat 2.5 Preview Free",
+      cost: { input: 0, output: 0 },
+      limit: { context: 1000000, output: 131072 },
+      reasoning: true,
+      tool_call: true,
+      interleaved: { field: "reasoning_content" },
+      modalities: { input: ["text", "image"], output: ["text"] },
+    },
+    "mimo-v2.6-flash-free": {
+      name: "MiMo-V2.6-Flash Free",
+      cost: { input: 0, output: 0 },
+      limit: { context: 200000, output: 32000 },
+      reasoning: true,
+      tool_call: true,
+      interleaved: { field: "reasoning_content" },
+      modalities: { input: ["text", "image", "audio", "video"], output: ["text"] },
+    },
+    "nemotron-3.5-lightning-free": {
+      name: "Nemotron 3.5 Lightning Free",
+      cost: { input: 0, output: 0 },
+      limit: { context: 262144, output: 262144 },
+      reasoning: true,
+      tool_call: true,
+      interleaved: { field: "reasoning_content" },
+    },
+    "big-pickle": {
+      name: "Big Pickle",
+      cost: { input: 0, output: 0 },
+      limit: { context: 200000, input: 160000, output: 32000 },
+      reasoning: true,
+      tool_call: true,
+      interleaved: { field: "reasoning_content" },
+    },
+    "space-bunny-free": {
+      name: "Space Bunny Free",
+      cost: { input: 0, output: 0 },
+      limit: { context: 1048576, input: 524288, output: 524288 },
+      reasoning: true,
+      tool_call: true,
+    },
+    "muse-spark-1.3-contributor-free": {
+      name: "Muse Spark 1.3 Free",
+      cost: { input: 0, output: 0 },
+      provider: { npm: SDK.responses },
+      limit: { context: 1048576, output: 131072 },
+      reasoning: true,
+      tool_call: true,
+      modalities: { input: ["text", "image", "video", "pdf", "audio"], output: ["text"] },
+      reasoning_options: [
+        { type: "effort", values: ["minimal", "low", "medium", "high", "xhigh"] },
+      ],
+    },
+  },
+};
+
+export function configModels(models) {
+  return Object.fromEntries(
+    Object.entries(models).map(([id, model]) => [
+      id,
+      {
+        id,
+        name: model.name,
+        provider: { npm: model.api.npm, api: model.api.url },
+        limit: model.limit,
+        reasoning: model.capabilities.reasoning,
+        tool_call: model.capabilities.toolcall,
+        attachment: model.capabilities.attachment,
+        modalities: {
+          input: Object.keys(model.capabilities.input).filter(
+            (key) => model.capabilities.input[key],
+          ),
+          output: Object.keys(model.capabilities.output).filter(
+            (key) => model.capabilities.output[key],
+          ),
+        },
+        cost: { input: 0, output: 0 },
+        variants: model.variants,
+        free: true,
+      },
+    ]),
+  );
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "opencode-zen-freex",
-  "version": "0.2.0",
+  "version": "0.2.2",
   "description": "OpenCode Zen's free models, for hosts that are not OpenCode: the public credential, automatic discovery and native streaming protocols",
   "type": "module",
   "main": "./index.mjs",
@@ -12,14 +12,17 @@
     "models.mjs",
     "stream.mjs",
     "tool-response.mjs",
+    "tools-smoke.mjs",
+    "capture.mjs",
     "README.md",
+    "MAINTAINING.md",
     "LICENSE"
   ],
   "keywords": ["opencode", "opencode-plugin", "zen", "free", "magpie"],
   "license": "MIT",
-  "repository": { "type": "git", "url": "git+https://github.com/tkhs101/opencode-zen-freex.git" },
-  "bugs": { "url": "https://github.com/tkhs101/opencode-zen-freex/issues" },
-  "homepage": "https://github.com/tkhs101/opencode-zen-freex#readme",
+  "repository": { "type": "git", "url": "git+https://github.com/tkhs101/OpenCode-Zen-FreeX.git" },
+  "bugs": { "url": "https://github.com/tkhs101/OpenCode-Zen-FreeX/issues" },
+  "homepage": "https://github.com/tkhs101/OpenCode-Zen-FreeX#readme",
   "scripts": {
     "test": "bun test",
     "check:gate": "bun tools-smoke.mjs",