opencode-zen-freex 0.0.0-stage → 0.2.0

package/LICENSE

@@ -0,0 +1,27 @@
+MIT License
+
+Copyright (c) 2026 xiaozhou26
+Copyright (c) 2026 opencode-zen-free contributors
+
+This is a maintained fork of the OpenCode Zen Free plugin from
+magpie-community/plugins, which is MIT licensed and carries the notice above.
+The fork is maintained separately because the free tier's request fingerprint
+moves faster than that repository follows it.
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -1,3 +1,125 @@
-# Temporary Holding Version
-
-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.
+# OpenCode Zen Free
+
+OpenCode Zen's free models for a host that is not OpenCode. Provider id:
+`opencode-zen-free`.
+
+Zen's free tier answers 403 FreeTierError ("can only be used from within
+OpenCode") to a request that isn't OpenCode's, and it reads the request body
+as well as its headers: the tools it knows by name have to be described the
+way OpenCode describes them. This plugin asks the endpoint that serves the
+free tier, and presents the tools the way OpenCode presents them while
+keeping the host's own tools, so its calls still run.
+
+This is a maintained fork of the plugin from `magpie-community/plugins`,
+which is MIT licensed. It is forked because that fingerprint moves faster
+than that repository follows it: its last release is still built for an
+endpoint that no longer serves the free tier. See [MAINTAINING.md](MAINTAINING.md)
+for how to keep it working, and `bun run check:gate` for whether it is
+working now.
+
+## Install
+
+```sh
+magpie plugin add opencode-zen-freex
+magpie plugin login opencode-zen-free
+```
+
+## Sign in
+
+Enter `public` in the key field. No personal API key is needed.
+The credential is kept in OpenCode's `auth.json` or magpie's
+`plugin-auth.json`.
+
+## Models
+
+The plugin discovers Zen's current free models, including their context
+windows and reasoning levels. Use `opencode-zen-free/<model>`, for example
+`opencode-zen-free/big-pickle`.
+
+Retired models and SystemOne models are excluded. The list is asked
+again each time the host lists models (magpie does this on start and every
+hour): a model Zen no longer gives free leaves it, and a new free one joins
+it. When Zen's list can't be read, the last list is kept. A request for a
+model that isn't free now gets a 404 naming the free ones; one made free
+since the last list is served after the list is asked again (at most once a
+minute). Availability and rate limits are set by Zen; the plugin has no
+remaining-quota data.
+
+## When the free tier stops answering
+
+A stale fingerprint does not look different from a working one until
+somebody is refused. Ask Zen which generations the plugin still speaks:
+
+```sh
+bun run check:gate
+```
+
+Each profile is reported as `answered`, `refused` (403), `superseded`
+(426 — Zen wants a newer OpenCode than the profile claims) or
+`unreachable`. Run it before a release and whenever a 403 is reported.
+
+If every profile is refused, capture the wording again from a current
+OpenCode: point a release at a local server and read the tools out of the
+request it makes. A refusal from the plugin says which wording went out
+and where to look, rather than leaving it to be guessed at.
+
+Note that the gate is not steady: it moved more than once in a day while
+this was being worked out, and repeated refusals from one address can
+themselves be answered for a while. Read a verdict here as "at this
+moment", and run it again before believing a change.
+
+## Requests
+
+Requests go to `https://opencode.ai/inference/v1` using each model's
+native Chat Completions, Responses or Anthropic Messages API. Streaming and
+ordinary JSON replies are supported.
+
+The agent's tools are preserved. Zen's models often call OpenCode's own
+tool names; such a call is given the agent's tool whose name differs only
+in case (`bash` to `Bash`), or else only in case and `_`/`-` (`todowrite`
+to `todo_write`, `webfetch` to `web_fetch`), when exactly one does. A
+call with no such tool (or with no name) is left out of the reply, and
+the reply's text says which name was left out; a turn whose every call
+was left out ends as an ordinary answer. Tools run in the agent.
+
+Zen's free tier reads the body as well as the headers, and answers a
+request only when the whole of it belongs to one generation of OpenCode:
+the User-Agent, the headers and the tools have to agree. Two generations
+are current, and the tools a request carries say which: `shell` and `read`
+are 2.x, `bash`, `glob`, `grep` and `read` are 1.x. A host that is OpenCode
+itself says which it is in its own User-Agent, and that is passed on rather
+than pinned, so it is never behind. Where nothing says, the tools decide
+and the User-Agent follows them.
+
+Within a generation, the tools Zen knows by name — `bash`, `glob`, `grep`,
+`read`, `write`, `edit` — have to be there and described the way OpenCode
+describes them. The first four are added when the host lacks them; the
+other two are only read when the host has them. A tool is never
+discarded: the host's own tool is kept whole, and only the wording sent
+upstream is replaced, so the call the model makes still fits the tool that
+runs it. A tool of any other name is not looked at.
+
+A tool that was *added* has nothing behind it: the agent has no such tool
+and a call to it is dropped. Describing it as OpenCode describes it is what
+Zen asks for, and it also makes the model want to call it, so a note saying
+so is placed after the opening Zen reads and before the closing it does
+not. That note is phrased about the one tool on purpose: a blanket "these
+tools are not available" was measured to stop the model using the host's
+own tools as well.
+
+The headers sent are exactly those of one generation and no more, and that
+set is a deliberate subset of everything Zen has been seen to accept.
+`x-opencode-request` was measured refused on 2026-10-14 and has never been
+measured to be needed, so it is not sent. `x-session-affinity` and
+`x-session-id` are in OpenCode's own header set upstream and have been
+measured refused, so they are not sent either. A test pins the set by name,
+because adding a header is the easiest way to break this plugin.
+
+Now and then Zen closes a streamed Chat Completions reply before its
+`[DONE]`. When the reply has said something and no tool call of it is
+unfinished, it ends there as an ordinary answer, and its text says it was
+cut short; asking again goes on. A reply cut short with a tool call
+unfinished, with nothing said, or collapsed for a client that doesn't
+stream fails with an error naming the reply's id and how much of it came.
+An Anthropic Messages or Responses reply cut short fails too: magpie
+tells it from a whole one and, where the model can, goes on with it.

package/core-tools.mjs

@@ -0,0 +1,53 @@
+// Which generation of OpenCode's request Zen's free tier will serve.
+//
+// Zen accepts a request only when the whole of it belongs to one generation:
+// the User-Agent, the header set and the tools have to agree. Two generations
+// are known to be current, and which one applies is the host's to decide:
+//
+//   1.x   bash, glob, grep, read  -  User-Agent opencode/<v> ai-sdk/provider-utils/<v> runtime/bun/<v>
+//   2.x   shell, read             -  User-Agent opencode/<channel>/<version>/<client>
+//
+// Within a generation, the tools named in `read` are compared against Zen's own
+// copy of OpenCode's, and the ones in `required` have to be there. Their data
+// lives in fingerprint.json, which is a capture of a real OpenCode rather than
+// anything written by hand; `bun run capture` takes a new one, and
+// `bun run check:gate` says whether Zen still accepts it.
+//
+// The descriptions there are the opening of OpenCode's, since that is the part
+// Zen reads, with the capture host's scratch directory and OS banner replaced
+// because those belong to the machine the capture ran on.
+
+import { readFileSync } from "node:fs";
+
+const captured = JSON.parse(readFileSync(new URL("./fingerprint.json", import.meta.url), "utf8"));
+
+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
+ * pinned User-Agent would not.
+ */
+export function generationOf(tools) {
+  const names = new Set((tools ?? []).map((tool) => tool?.function?.name ?? tool?.name));
+  if (names.has("shell")) return "2.x";
+  if (names.has("bash")) return "1.x";
+  return undefined;
+}
+
+/**
+ * The User-Agent that generation of OpenCode sends, for a protocol. Each
+ * protocol's ai-sdk package bundles its own provider-utils, so 1.x differs by
+ * protocol and 2.x does not.
+ */
+export function agentFor(generation, protocol = "chat") {
+  const agent = PROFILES[generation].agent;
+  return agent.providerUtils
+    ? `opencode/${agent.opencode} ai-sdk/provider-utils/${agent.providerUtils[protocol]} ${agent.runtime}`
+    : `opencode/${agent.channel}/${agent.opencode}/${agent.client}`;
+}
+
+export { readNames };

package/fingerprint.json

@@ -0,0 +1,241 @@
+{
+  "_note": "Captured from a real OpenCode by capture.mjs. Refresh with: bun run capture",
+  "profiles": {
+    "1.x": {
+      "agent": {
+        "opencode": "1.19.0",
+        "providerUtils": {
+          "chat": "4.0.23",
+          "responses": "4.0.40",
+          "anthropic": "4.0.46"
+        },
+        "runtime": "runtime/bun/1.3.14"
+      },
+      "required": [
+        "bash",
+        "glob",
+        "grep",
+        "read"
+      ],
+      "tools": {
+        "bash": {
+          "name": "bash",
+          "description": "Executes a given Windows PowerShell (5.1) command with optional timeout, ensuring proper handling and security measures.\n\nBe aware: OS: linux, Shell: bash\n\nAll commands run in the current working directory by default. Use the `workdir` parameter if you need to run a command in a different directory. AVOID changing directories inside the command - use `workdir` instead.\n\nUse `/tmp` for temporary work outside the workspace. This directory has already been created, already exists, and is pre-approved for external directory access.\n\nIMPORTANT: This tool is for terminal operations like git, npm, docker, etc. DO NOT use it for file operations (reading, writing, editing, searching, finding files) - use the specialized tools for this instead.\n\n# Windows PowerShell (5.1) shell notes\n- Use `cmd1; if ($?) { cmd2 }` to chain dependent commands.\n- Use double quotes for interpolated strings (`\"Hello $name\"`), single quotes for verbatim strings.\n- Prefer full cmdlet names like `Get-ChildItem`, `Set-Content`, `Remove-Item`, and `New-Item` over aliases.\n- Use `$(...)` for subexpressions. Use `@(...)` for array expressions.\n- To call a native executable whose path contains spaces, use the call opera",
+          "parameters": {
+            "$schema": "https://json-schema.org/draft/2020-12/schema",
+            "type": "object",
+            "properties": {
+              "command": {
+                "type": "string",
+                "description": "The command to execute"
+              },
+              "timeout": {
+                "minimum": -9007199254740991,
+                "exclusiveMinimum": 0,
+                "type": "integer",
+                "maximum": 9007199254740991,
+                "description": "Optional timeout in milliseconds"
+              },
+              "workdir": {
+                "type": "string",
+                "description": "The working directory to run the command in. Defaults to the current directory. Use this instead of 'cd' commands."
+              }
+            },
+            "required": [
+              "command"
+            ]
+          }
+        },
+        "glob": {
+          "name": "glob",
+          "description": "- Fast file pattern matching tool that works with any codebase size\n- Supports glob patterns like \"**/*.js\" or \"src/**/*.ts\"\n- Returns matching file paths\n- Use this tool when you need to find files by name patterns\n- When you are doing an open-ended search that may require multiple rounds of globbing and grepping, use the Task tool instead\n- You have the capability to call multiple tools in a single response. It is always better to speculatively perform multiple searches as a batch that are potentially useful.\n",
+          "parameters": {
+            "$schema": "https://json-schema.org/draft/2020-12/schema",
+            "type": "object",
+            "properties": {
+              "pattern": {
+                "type": "string",
+                "description": "The glob pattern to match files against"
+              },
+              "path": {
+                "type": "string",
+                "description": "The directory to search in. If not specified, the current working directory will be used. IMPORTANT: Omit this field to use the default directory. DO NOT enter \"undefined\" or \"null\" - simply omit it for the default behavior. Must be a valid directory path if provided."
+              }
+            },
+            "required": [
+              "pattern"
+            ]
+          }
+        },
+        "grep": {
+          "name": "grep",
+          "description": "- Fast content search tool that works with any codebase size\n- Searches file contents using regular expressions\n- Supports full regex syntax (eg. \"log.*Error\", \"function\\s+\\w+\", etc.)\n- Filter files by pattern with the include parameter (eg. \"*.js\", \"*.{ts,tsx}\")\n- Returns file paths and line numbers with matching lines\n- Use this tool when you need to find files containing specific patterns\n- If you need to identify/count the number of matches within files, use the Bash tool with `rg` (ripgrep) directly. Do NOT use `grep`.\n- When you are doing an open-ended search that may require multiple rounds of globbing and grepping, use the Task tool instead\n",
+          "parameters": {
+            "$schema": "https://json-schema.org/draft/2020-12/schema",
+            "type": "object",
+            "properties": {
+              "pattern": {
+                "type": "string",
+                "description": "The regex pattern to search for in file contents"
+              },
+              "path": {
+                "type": "string",
+                "description": "The directory to search in. Defaults to the current working directory."
+              },
+              "include": {
+                "type": "string",
+                "description": "File pattern to include in the search (e.g. \"*.js\", \"*.{ts,tsx}\")"
+              }
+            },
+            "required": [
+              "pattern"
+            ]
+          }
+        },
+        "read": {
+          "name": "read",
+          "description": "Read a file or directory from the local filesystem. If the path does not exist, an error is returned.\n\nUsage:\n- The filePath parameter should be an absolute path.\n- By default, this tool returns up to 2000 lines from the start of the file.\n- The offset parameter is the line number to start from (1-indexed).\n- To read later sections, call this tool again with a larger offset.\n- Use the grep tool to find specific content in large files or files with long lines.\n- If you are unsure of the correct file path, use the glob tool to look up filenames by glob pattern.\n- Contents are returned with each line prefixed by its line number as `<line>: <content>`. For example, if a file has contents \"foo\\n\", you will receive \"1: foo\\n\". For directories, entries are returned one per line (without line numbers) with a trailing `/` for subdirectories.\n- Any line longer than 2000 characters is truncated.\n- Call this tool in parallel when you know there are multiple files you want to read.\n- Avoid tiny repeated slices (30 line chunks). If you need more context, read a larger window.\n- This tool can read image files and PDFs and return them as file attachments.\n",
+          "parameters": {
+            "$schema": "https://json-schema.org/draft/2020-12/schema",
+            "type": "object",
+            "properties": {
+              "filePath": {
+                "type": "string",
+                "description": "The absolute path to the file or directory to read"
+              },
+              "offset": {
+                "minimum": 0,
+                "type": "integer",
+                "maximum": 9007199254740991,
+                "description": "The line number to start reading from (1-indexed)"
+              },
+              "limit": {
+                "minimum": 0,
+                "type": "integer",
+                "maximum": 9007199254740991,
+                "description": "The maximum number of lines to read (defaults to 2000)"
+              }
+            },
+            "required": [
+              "filePath"
+            ]
+          }
+        },
+        "edit": {
+          "name": "edit",
+          "description": "Performs exact string replacements in files. \n\nUsage:\n- You must use your `Read` tool at least once in the conversation before editing. This tool will error if you attempt an edit without reading the file. \n- When editing text from Read tool output, ensure you preserve the exact indentation (tabs/spaces) as it appears AFTER the line number prefix. The line number prefix format is: line number + colon + space (e.g., `1: `). Everything after that space is the actual file content to match. Never include any part of the line number prefix in the oldString or newString.\n- ALWAYS prefer editing existing files in the codebase. NEVER write new files unless explicitly required.\n- Only use emojis if the user explicitly requests it. Avoid adding emojis to files unless asked.\n- The edit will FAIL if `oldString` is not found in the file with an error \"oldString not found in content\".\n- The edit will FAIL if `oldString` is found multiple times in the file with an error \"Found multiple matches for oldString. Provide more surrounding lines in oldString to identify the correct match.\" Either provide a larger string with more surrounding context to make it unique or use `replaceAll` to change every ",
+          "parameters": {
+            "$schema": "https://json-schema.org/draft/2020-12/schema",
+            "type": "object",
+            "properties": {
+              "filePath": {
+                "type": "string",
+                "description": "The absolute path to the file to modify"
+              },
+              "oldString": {
+                "type": "string",
+                "description": "The text to replace"
+              },
+              "newString": {
+                "type": "string",
+                "description": "The text to replace it with (must be different from oldString)"
+              },
+              "replaceAll": {
+                "type": "boolean",
+                "description": "Replace all occurrences of oldString (default false)"
+              }
+            },
+            "required": [
+              "filePath",
+              "oldString",
+              "newString"
+            ]
+          }
+        },
+        "write": {
+          "name": "write",
+          "description": "Writes a file to the local filesystem.\n\nUsage:\n- This tool will overwrite the existing file if there is one at the provided path.\n- If this is an existing file, you MUST use the Read tool first to read the file's contents. This tool will fail if you did not read the file first.\n- ALWAYS prefer editing existing files in the codebase. NEVER write new files unless explicitly required.\n- NEVER proactively create documentation files (*.md) or README files. Only create documentation files if explicitly requested by the User.\n- Only use emojis if the user explicitly requests it. Avoid writing emojis to files unless asked.\n",
+          "parameters": {
+            "$schema": "https://json-schema.org/draft/2020-12/schema",
+            "type": "object",
+            "properties": {
+              "content": {
+                "type": "string",
+                "description": "The content to write to the file"
+              },
+              "filePath": {
+                "type": "string",
+                "description": "The absolute path to the file to write (must be absolute, not relative)"
+              }
+            },
+            "required": [
+              "content",
+              "filePath"
+            ]
+          }
+        }
+      }
+    },
+    "2.x": {
+      "agent": {
+        "channel": "latest",
+        "opencode": "2.0.29",
+        "client": "cli"
+      },
+      "required": [
+        "shell",
+        "read"
+      ],
+      "tools": {
+        "shell": {
+          "name": "shell",
+          "description": "Execute a shell command and return its output. Commands run on Windows using PowerShell (5.1). Quote file paths containing spaces or special characters. Prefer dedicated tools over shell commands when possible. When output is large, the full result is saved to a file and a truncated preview is returned. Rely on automatic truncation unless filtering the output is more useful. Commands accept an optional timeout, background commands have no timeout by default. Background commands return immediately, and you will be notified when they complete.",
+          "parameters": {
+            "type": "object",
+            "properties": {
+              "command": {
+                "type": "string",
+                "description": "Shell command string to execute"
+              },
+              "workdir": {
+                "type": "string",
+                "description": "Working directory to execute the command in."
+              },
+              "timeout": {
+                "type": "number",
+                "description": "Timeout in milliseconds. Set to 0 to disable the timeout."
+              }
+            },
+            "required": [
+              "command"
+            ]
+          }
+        },
+        "read": {
+          "name": "read",
+          "description": "Read the contents of a file or directory. Supports text files, images, and PDFs. Images and PDFs are presented directly to the model. Each text line is prefixed by its 1-based line number as <line>: <content>. The prefix is for reference and is not part of the file content. Directory entries are returned one per line. Use offset and limit to read large files or directories in sections. Prefer one larger read over many small slices, and use grep to find specific content in large files.",
+          "parameters": {
+            "type": "object",
+            "properties": {
+              "path": {
+                "type": "string",
+                "description": "File or directory to read"
+              },
+              "offset": {
+                "type": "number",
+                "description": "The line or directory entry to start reading from (1-based)"
+              },
+              "limit": {
+                "type": "number",
+                "description": "The maximum number of lines or directory entries to read"
+              }
+            },
+            "required": [
+              "path"
+            ]
+          }
+        }
+      }
+    }
+  }
+}

package/index.mjs

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

package/models.mjs

@@ -0,0 +1,148 @@
+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,
+      },
+    ]),
+  );
+}

package/package.json

@@ -1,6 +1,29 @@
 {
   "name": "opencode-zen-freex",
-  "version": "0.0.0-stage",
-  "stub": true,
-  "description": "Temporary package placeholder for staged publishing"
+  "version": "0.2.0",
+  "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",
+  "files": [
+    "index.mjs",
+    "provider.mjs",
+    "core-tools.mjs",
+    "fingerprint.json",
+    "models.mjs",
+    "stream.mjs",
+    "tool-response.mjs",
+    "README.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",
+  "scripts": {
+    "test": "bun test",
+    "check:gate": "bun tools-smoke.mjs",
+    "capture": "bun capture.mjs"
+  },
+  "magpie": { "icon": "https://opencode.ai/favicon-v3.ico", "maxConcurrency": 2 }
 }