@magpie-community/opencode-zen-free-auth 0.1.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 xiaozhou26
+
+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

@@ -0,0 +1,36 @@
+# OpenCode Zen Free
+
+OpenCode Zen's free models in magpie and OpenCode. Provider id:
+`opencode-zen-free`.
+
+## Install
+
+```sh
+magpie plugin add @magpie-community/opencode-zen-free-auth
+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. Availability and rate
+limits are set by Zen; the plugin has no remaining-quota data.
+
+## Requests
+
+Requests go to `https://opencode.ai/zen/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. If Zen calls an added tool, its name is
+mapped to the agent's unique case-insensitive match (`bash` to `Bash`).
+A call with no matching tool returns an error. Tools run in the agent.

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

@@ -0,0 +1,13 @@
+{
+  "name": "@magpie-community/opencode-zen-free-auth",
+  "version": "0.1.0",
+  "description": "OpenCode Zen free models through the public credential, with native streaming protocols",
+  "type": "module",
+  "main": "./index.mjs",
+  "files": ["index.mjs", "provider.mjs", "models.mjs", "stream.mjs", "tool-response.mjs", "README.md", "LICENSE"],
+  "keywords": ["opencode", "opencode-plugin", "zen", "free", "magpie"],
+  "license": "MIT",
+  "repository": { "type": "git", "url": "https://github.com/magpie-community/plugins", "directory": "packages/zen-free" },
+  "scripts": { "test": "bun test" },
+  "magpie": { "icon": "https://opencode.ai/favicon-v3.ico", "maxConcurrency": 2 }
+}

package/provider.mjs

@@ -0,0 +1,290 @@
+import { createHash, randomUUID } from "node:crypto";
+import {
+  PROVIDER,
+  SDK,
+  bootstrapProvider,
+  buildModels,
+  configModels,
+  parseProtocolDocs,
+} from "./models.mjs";
+import { collapseResponse } from "./stream.mjs";
+import { guardToolResponse } from "./tool-response.mjs";
+
+const DEFAULT_BASE = "https://opencode.ai/zen/v1";
+const CATALOG = "https://models.opencode.ai/api.json";
+const DOCS =
+  "https://raw.githubusercontent.com/anomalyco/opencode/dev/packages/web/src/content/docs/zen.mdx";
+const PATHS = { chat: "/chat/completions", responses: "/responses", anthropic: "/messages" };
+const CORE_TOOLS = ["bash", "edit", "glob", "grep", "read"];
+const OPENCODE_VERSION = "1.18.34";
+
+function httpURL(value) {
+  const url = new URL(value);
+  if (
+    !["http:", "https:"].includes(url.protocol) ||
+    url.username ||
+    url.password ||
+    url.search ||
+    url.hash
+  ) {
+    throw new Error("Expected an HTTP(S) URL without credentials, query or fragment");
+  }
+  return url.href.replace(/\/+$/, "");
+}
+
+function requirePublic(auth) {
+  if (auth?.type !== "api" || auth.key !== "public") {
+    throw new Error(
+      "OpenCode Zen Free uses the public credential. Enable its free access login method.",
+    );
+  }
+}
+
+async function readRemote(url, json, headers, callerSignal) {
+  const timeout = AbortSignal.timeout(15000);
+  const signal = callerSignal ? AbortSignal.any([callerSignal, timeout]) : timeout;
+  const response = await fetch(url, { headers, signal });
+  if (!response.ok) {
+    await response.body?.cancel();
+    throw new Error(`Model discovery returned HTTP ${response.status}`);
+  }
+  return json ? response.json() : response.text();
+}
+
+function normalizeTools(body, protocol) {
+  if (body.tools !== undefined && !Array.isArray(body.tools)) {
+    throw new Error("tools must be an array");
+  }
+  body.tools ??= [];
+  const present = new Set(
+    body.tools.map((tool) => (protocol === "chat" ? tool?.function?.name : tool?.name)),
+  );
+  const declared = new Set([...present].filter((name) => typeof name === "string"));
+  if (protocol === "chat" && Array.isArray(body.functions)) {
+    for (const tool of body.functions) if (typeof tool?.name === "string") declared.add(tool.name);
+  }
+  const injected = new Set();
+  for (const name of CORE_TOOLS) {
+    if (present.has(name)) continue;
+    injected.add(name);
+    const parameters = { type: "object", properties: {}, additionalProperties: false };
+    const definition = { name, description: "Not available. Never call this tool." };
+    body.tools.push(
+      protocol === "chat"
+        ? { type: "function", function: { ...definition, parameters } }
+        : protocol === "anthropic"
+          ? { ...definition, input_schema: parameters }
+          : { type: "function", ...definition, parameters },
+    );
+  }
+  return { declared, injected };
+}
+
+function sessionID(headers, body) {
+  let signal;
+  for (const name of [
+    "x-opencode-session",
+    "x-session-affinity",
+    "x-session-id",
+    "conversation-id",
+  ]) {
+    if (headers.get(name)) {
+      signal = headers.get(name);
+      break;
+    }
+  }
+  if (!signal && typeof body.metadata?.session_id === "string") signal = body.metadata.session_id;
+  if (!signal) {
+    const messages = body.messages ?? body.input;
+    const first = Array.isArray(messages)
+      ? messages.find((message) => message.role === "user")?.content
+      : messages;
+    signal = first ? JSON.stringify(first) : randomUUID();
+  }
+  if (/^ses_[0-9a-f]{12}[0-9A-Za-z]{14}$/.test(signal)) return signal;
+  // Keep conversation affinity using OpenCode's canonical session format.
+  const hash = createHash("sha256").update(`ses\0${signal}`).digest("hex");
+  let value = BigInt(`0x${hash.slice(12, 32)}`);
+  let suffix = "";
+  const alphabet = "0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz";
+  for (let i = 0; i < 14; i++) {
+    suffix = alphabet[Number(value % 62n)] + suffix;
+    value /= 62n;
+  }
+  return `ses_${hash.slice(0, 12)}${suffix}`;
+}
+
+async function server(_input, options = {}) {
+  const baseURL = httpURL(options.baseURL ?? DEFAULT_BASE);
+  const catalogURL = httpURL(options.catalogURL ?? CATALOG);
+  const docsURL = httpURL(options.docsURL ?? DOCS);
+  let known = buildModels(Object.keys(bootstrapProvider.models), bootstrapProvider, {}, baseURL);
+  let metadata = bootstrapProvider;
+  let protocols = {};
+  let listed = false;
+
+  async function discover(signal) {
+    const headers = { authorization: "Bearer public", "x-opencode-client": "cli" };
+    const [listing, catalog, docs] = await Promise.allSettled([
+      readRemote(`${baseURL}/models`, true, headers, signal),
+      readRemote(catalogURL, true, undefined, signal),
+      readRemote(docsURL, false, undefined, signal),
+    ]);
+    signal?.throwIfAborted();
+    let partial = false;
+    if (catalog.status === "fulfilled" && catalog.value?.opencode?.models) {
+      metadata = catalog.value.opencode;
+    } else {
+      partial = true;
+    }
+    if (docs.status === "fulfilled" && Object.keys(parseProtocolDocs(docs.value)).length) {
+      protocols = parseProtocolDocs(docs.value);
+    } else {
+      partial = true;
+    }
+    if (listing.status !== "fulfilled" || !Array.isArray(listing.value?.data)) {
+      const fallback = { ...known };
+      fallback[Symbol.for("magpie.fellBack")] = true;
+      return fallback;
+    }
+    const ids = listing.value.data.map((item) => item.id);
+    const discovered = buildModels(ids, metadata, protocols, baseURL);
+    if (partial) {
+      // Preserve previously verified models only while they remain in the live catalog.
+      for (const id of ids) {
+        if (!discovered[id] && !metadata.models?.[id] && !protocols[id] && known[id]) {
+          discovered[id] = known[id];
+        }
+      }
+      discovered[Symbol.for("magpie.fellBack")] = true;
+    }
+    known = discovered;
+    listed = true;
+    return discovered;
+  }
+
+  return {
+    async config(cfg) {
+      cfg.provider ??= {};
+      cfg.provider[PROVIDER] ??= {
+        name: "OpenCode Zen Free",
+        npm: SDK.chat,
+        api: baseURL,
+        models: configModels(known),
+      };
+    },
+    auth: {
+      provider: PROVIDER,
+      icon: "https://opencode.ai/favicon-v3.ico",
+      maxConcurrency: 2,
+      methods: [
+        {
+          type: "api",
+          label: "Zen 免费访问（密钥填写 public）",
+          placeholder: "public",
+          async authorize() {
+            return { type: "success", key: "public" };
+          },
+        },
+      ],
+      async loader(getAuth) {
+        const auth = await getAuth();
+        if (!auth) return {};
+        requirePublic(auth);
+        return {
+          baseURL,
+          apiKey: "public",
+          async fetch(input, init) {
+            requirePublic(await getAuth());
+            const request = new Request(input, init);
+            const protocol = Object.keys(PATHS).find(
+              (key) => request.url === `${baseURL}${PATHS[key]}`,
+            );
+            if (!protocol || request.method !== "POST")
+              throw new Error("Unsupported Zen endpoint or method");
+            request.signal.throwIfAborted();
+            const body = await request.json();
+            if (!body || typeof body !== "object" || Array.isArray(body))
+              throw new Error("Expected a JSON request object");
+            if (!listed && !Object.hasOwn(known, body.model)) {
+              await discover(request.signal);
+            }
+            const model = known[body.model];
+            if (!model || model.api.npm !== SDK[protocol]) {
+              throw new Error(
+                "Model is not an available free model for this protocol. Refresh the model list.",
+              );
+            }
+            const streaming = body.stream === true;
+            body.stream = true;
+            const toolPolicy = normalizeTools(body, protocol);
+            if (protocol === "chat")
+              body.stream_options = { ...body.stream_options, include_usage: true };
+            const headers = new Headers(request.headers);
+            for (const name of [
+              "authorization",
+              "x-api-key",
+              "x-goog-api-key",
+              "content-length",
+              "content-encoding",
+              "host",
+              "cookie",
+            ]) {
+              headers.delete(name);
+            }
+            headers.set("content-type", "application/json");
+            headers.set("accept", "text/event-stream");
+            headers.set("user-agent", `opencode/${OPENCODE_VERSION}`);
+            headers.set("x-opencode-client", "cli");
+            headers.set("x-opencode-request", `req_${randomUUID().replaceAll("-", "")}`);
+            if (!headers.has("x-opencode-project")) {
+              const project = _input?.project;
+              headers.set(
+                "x-opencode-project",
+                project?.vcs === "git" && project.id ? project.id : "global",
+              );
+            }
+            const session = sessionID(headers, body);
+            for (const name of ["x-session-id", "x-opencode-session", "x-session-affinity"])
+              headers.set(name, session);
+            if (protocol === "anthropic") {
+              headers.set("x-api-key", "public");
+              if (!headers.has("anthropic-version")) headers.set("anthropic-version", "2023-06-01");
+            } else {
+              headers.set("authorization", "Bearer public");
+            }
+            const response = await fetch(request.url, {
+              method: "POST",
+              headers,
+              body: JSON.stringify(body),
+              signal: request.signal,
+              redirect: "error",
+            });
+            const guarded = await guardToolResponse(response, protocol, toolPolicy);
+            return streaming ? guarded : collapseResponse(guarded, protocol);
+          },
+        };
+      },
+      async usage() {
+        return { plan: "OpenCode Zen Free", windows: [] };
+      },
+    },
+    provider: {
+      id: PROVIDER,
+      async models(provider, { auth } = {}) {
+        if (!auth) return provider.models;
+        requirePublic(auth);
+        return discover();
+      },
+    },
+    async "chat.headers"(input, output) {
+      if (![PROVIDER, `${PROVIDER}-plugin`].includes(input.model?.providerID) || !input.sessionID)
+        return;
+      output.headers["x-session-id"] = input.sessionID;
+      output.headers["x-opencode-session"] = input.sessionID;
+      output.headers["x-session-affinity"] = input.sessionID;
+    },
+  };
+}
+
+export default { id: PROVIDER, server };