@suncreation/opencode-claude-patch 0.1.0

package/README.md

@@ -0,0 +1,105 @@
+# opencode-anthropic-oauth-patch
+
+Installable OpenCode plugin for sanitizing Anthropic OAuth / Claude request shape, with helper exports for lower-level integrations.
+
+This is meant for OpenCode/oh-my-opencode-style integrations where Claude OAuth requests break because extra Anthropic-incompatible fields are injected into the request path.
+
+## What it patches automatically as an OpenCode plugin
+
+- Removes `thinking`, `output_config`, and related Anthropic-problematic option fields from OpenCode provider options
+- Rewrites OpenCode system prompt strings into a single Claude-Code-compatible system string
+- Sets Claude-Code-compatible Anthropic headers by default
+- Installs a targeted global `fetch` patch that sanitizes outbound Anthropic OAuth message bodies, including final `system[*].cache_control` removal
+
+## How the automatic patch works
+
+The root plugin uses two layers:
+
+1. OpenCode hooks (`chat.params`, `chat.headers`, `experimental.chat.system.transform`) for public-ABI-safe fixes
+2. a narrowly targeted `globalThis.fetch` wrapper that only patches `https://api.anthropic.com/v1/messages...` requests carrying `Authorization: Bearer ...`
+
+That second layer is what makes the package automatic for the `cache_control` problem too.
+
+## Install
+
+Add the package to your `opencode.json` plugin list:
+
+```json
+{
+  "$schema": "https://opencode.ai/config.json",
+  "plugin": [
+    "@suncreation/opencode-claude-patch"
+  ]
+}
+```
+
+Install it from this repository:
+
+```bash
+npm install /Users/admin/Projects/subscription-llm/npm/opencode-anthropic-oauth-patch
+```
+
+If you later publish it, keep the same `plugin` entry and install with:
+
+```bash
+npm install @suncreation/opencode-claude-patch
+```
+
+OpenCode will auto-install npm plugins referenced in `opencode.json` at startup.
+
+## What the root package export does
+
+The root package export is an OpenCode plugin function. Once installed and listed in `opencode.json`, it auto-applies:
+
+- `chat.params` patching for Anthropic/Claude models
+- `chat.headers` patching for Claude-compatible headers
+- `experimental.chat.system.transform` patching for a single Claude-Code-style system prompt
+- a targeted `globalThis.fetch` patch for final Anthropic OAuth request-body cleanup
+
+No extra wiring is needed.
+
+## Optional environment toggles
+
+```bash
+OPENCODE_ANTHROPIC_OAUTH_SET_HEADERS=0
+OPENCODE_ANTHROPIC_OAUTH_SYSTEM_PREFIX="You are Claude Code, Anthropic's official CLI for Claude."
+```
+
+## Helper subpath for lower-level integrations
+
+```js
+import {
+  createAnthropicOAuthPatchedFetch,
+  mergePatchHeaders,
+  normalizeAnthropicSystemStrings,
+  sanitizeAnthropicOptions
+} from "@suncreation/opencode-claude-patch/helpers";
+
+// if published:
+// import { ... } from "@suncreation/opencode-anthropic-oauth-patch/helpers";
+
+const options = sanitizeAnthropicOptions({
+  thinking: { type: "adaptive" },
+  output_config: { effort: "max" }
+});
+
+const headers = mergePatchHeaders({});
+const system = normalizeAnthropicSystemStrings([
+  "Be concise.",
+  "Answer in Korean."
+]);
+
+const patchedFetch = createAnthropicOAuthPatchedFetch(fetch, {
+  ensureClaudeCodeSystem: true,
+  normalizeSystemToUserMessage: true
+});
+
+console.log(options, headers, system, typeof patchedFetch);
+```
+
+## Notes
+
+- The root export is safe for `opencode.json -> plugin` installation.
+- The `./helpers` subpath is for deeper interceptors or forks.
+- It does not mint OAuth tokens or bypass account-level/provider policy restrictions.
+- This package is targeted at Claude OAuth / oh-my-opencode-style setups. If you use Anthropic API keys and want native reasoning features, do not enable it globally.

package/package.json

@@ -0,0 +1,36 @@
+{
+  "name": "@suncreation/opencode-claude-patch",
+  "version": "0.1.0",
+  "description": "Reusable Anthropic OAuth request sanitizer for OpenCode and similar tools",
+  "type": "module",
+  "main": "./src/index.js",
+  "types": "./src/index.d.ts",
+  "exports": {
+    ".": {
+      "types": "./src/index.d.ts",
+      "import": "./src/index.js"
+    },
+    "./helpers": {
+      "types": "./src/helpers.d.ts",
+      "import": "./src/helpers.js"
+    }
+  },
+  "files": [
+    "src",
+    "README.md"
+  ],
+  "scripts": {
+    "test": "node --test"
+  },
+  "keywords": [
+    "anthropic",
+    "oauth",
+    "opencode",
+    "claude",
+    "patch"
+  ],
+  "license": "MIT"
+  ,"publishConfig": {
+    "access": "public"
+  }
+}

package/src/helpers.d.ts

@@ -0,0 +1,29 @@
+export interface PatchOptions {
+  ensureClaudeCodeSystem?: boolean;
+  normalizeSystemToUserMessage?: boolean;
+  systemPrefix?: string;
+}
+
+export declare const DEFAULT_SYSTEM_PREFIX: string;
+export declare const DEFAULT_PATCH_HEADERS: Record<string, string>;
+
+export declare function sanitizeAnthropicOAuthBody<T>(body: T, options?: PatchOptions): T;
+export declare function sanitizeAnthropicOptions<T>(options: T): T;
+export declare function normalizeAnthropicSystemStrings(system: unknown, options?: PatchOptions): string[];
+export declare function mergePatchHeaders(
+  headers?: Record<string, string>,
+  overrides?: Record<string, string>
+): Record<string, string>;
+export declare function isAnthropicClaudeModel(model: unknown): boolean;
+export declare function isOpenCodeAnthropicPatchTarget(input: unknown): boolean;
+export declare function shouldPatchAnthropicOAuthRequest(url: string, init?: RequestInit): boolean;
+export declare function patchAnthropicOAuthRequest(
+  url: string,
+  init?: RequestInit,
+  options?: PatchOptions
+): { url: string; init: RequestInit; patched: boolean; body?: Record<string, unknown> };
+export declare function createAnthropicOAuthPatchedFetch(
+  fetchImpl: typeof fetch,
+  options?: PatchOptions
+): typeof fetch;
+export declare function installGlobalAnthropicOAuthFetchPatch(options?: PatchOptions): boolean;

package/src/helpers.js

@@ -0,0 +1,260 @@
+const DEFAULT_SYSTEM_PREFIX = "You are Claude Code, Anthropic's official CLI for Claude.";
+
+const DEFAULT_PATCH_HEADERS = {
+  "anthropic-beta": "oauth-2025-04-20,interleaved-thinking-2025-05-14,claude-code-20250219",
+  "anthropic-version": "2023-06-01",
+  "user-agent": "claude-cli/2.1.2 (external, cli)"
+};
+
+const FETCH_PATCH_MARKER = Symbol.for("opencode.anthropic.oauth.patch.fetch");
+
+function isPlainObject(value) {
+  return value !== null && typeof value === "object" && !Array.isArray(value);
+}
+
+function deepClone(value) {
+  return value === undefined ? undefined : JSON.parse(JSON.stringify(value));
+}
+
+function isAnthropicMessagesUrl(url) {
+  if (typeof url !== "string") {
+    return false;
+  }
+
+  return /^https:\/\/api\.anthropic\.com\/v1\/messages(?:\?|$)/.test(url);
+}
+
+function hasOAuthBearer(headers) {
+  if (!headers) {
+    return false;
+  }
+
+  if (typeof Headers !== "undefined" && headers instanceof Headers) {
+    const authorization = headers.get("authorization");
+    return typeof authorization === "string" && authorization.toLowerCase().startsWith("bearer ");
+  }
+
+  if (Array.isArray(headers)) {
+    for (const [key, value] of headers) {
+      if (String(key).toLowerCase() === "authorization") {
+        return String(value).toLowerCase().startsWith("bearer ");
+      }
+    }
+    return false;
+  }
+
+  if (isPlainObject(headers)) {
+    for (const [key, value] of Object.entries(headers)) {
+      if (key.toLowerCase() === "authorization") {
+        return typeof value === "string" && value.toLowerCase().startsWith("bearer ");
+      }
+    }
+  }
+
+  return false;
+}
+
+function extractBody(init) {
+  if (!init || !("body" in init)) {
+    return { body: undefined, bodyType: "missing" };
+  }
+
+  if (typeof init.body === "string") {
+    return { body: JSON.parse(init.body), bodyType: "json-string" };
+  }
+
+  if (isPlainObject(init.body)) {
+    return { body: deepClone(init.body), bodyType: "object" };
+  }
+
+  return { body: undefined, bodyType: "unsupported" };
+}
+
+function stripKnownAnthropicProblemFields(node) {
+  if (Array.isArray(node)) {
+    return node.map(stripKnownAnthropicProblemFields);
+  }
+
+  if (!isPlainObject(node)) {
+    return node;
+  }
+
+  const next = {};
+  for (const [key, value] of Object.entries(node)) {
+    if (
+      key === "thinking" ||
+      key === "output_config" ||
+      key === "outputConfig" ||
+      key === "cache_control" ||
+      key === "cacheControl"
+    ) {
+      continue;
+    }
+
+    if (key === "effort" && isPlainObject(node) && ("thinking" in node || "output_config" in node || "outputConfig" in node)) {
+      continue;
+    }
+
+    next[key] = stripKnownAnthropicProblemFields(value);
+  }
+  return next;
+}
+
+function mergeSystemTextIntoFirstUserMessage(messages, text) {
+  if (!text) {
+    return messages;
+  }
+
+  const injected = `<SYSTEM_INSTRUCTIONS>\n${text}\n</SYSTEM_INSTRUCTIONS>`;
+  const nextMessages = Array.isArray(messages) ? messages.map((message) => ({ ...message })) : [];
+
+  if (nextMessages.length > 0 && nextMessages[0].role === "user" && typeof nextMessages[0].content === "string") {
+    nextMessages[0].content = `${injected}\n\n${nextMessages[0].content}`;
+    return nextMessages;
+  }
+
+  nextMessages.unshift({ role: "user", content: injected });
+  return nextMessages;
+}
+
+export function sanitizeAnthropicOAuthBody(body, options = {}) {
+  if (!isPlainObject(body)) {
+    return body;
+  }
+
+  const {
+    ensureClaudeCodeSystem = false,
+    normalizeSystemToUserMessage = false,
+    systemPrefix = DEFAULT_SYSTEM_PREFIX
+  } = options;
+
+  const nextBody = stripKnownAnthropicProblemFields(deepClone(body));
+
+  if (ensureClaudeCodeSystem || normalizeSystemToUserMessage) {
+    const systemText = [];
+
+    if (Array.isArray(nextBody.system)) {
+      for (const entry of nextBody.system) {
+        if (isPlainObject(entry) && typeof entry.text === "string" && entry.text !== systemPrefix) {
+          systemText.push(entry.text);
+        }
+      }
+    }
+
+    nextBody.system = [{ type: "text", text: systemPrefix }];
+
+    if (normalizeSystemToUserMessage) {
+      nextBody.messages = mergeSystemTextIntoFirstUserMessage(nextBody.messages, systemText.join("\n\n"));
+    }
+  }
+
+  return nextBody;
+}
+
+export function sanitizeAnthropicOptions(options) {
+  if (!isPlainObject(options)) {
+    return options;
+  }
+
+  return stripKnownAnthropicProblemFields(deepClone(options));
+}
+
+export function normalizeAnthropicSystemStrings(system, options = {}) {
+  const { systemPrefix = DEFAULT_SYSTEM_PREFIX } = options;
+  const values = Array.isArray(system) ? system.filter((entry) => typeof entry === "string" && entry.trim()) : [];
+  const extra = values.filter((entry) => entry !== systemPrefix).join("\n\n");
+
+  if (!extra) {
+    return [systemPrefix];
+  }
+
+  return [`${systemPrefix}\n\n<SYSTEM_INSTRUCTIONS>\n${extra}\n</SYSTEM_INSTRUCTIONS>`];
+}
+
+export function mergePatchHeaders(headers = {}, overrides = {}) {
+  return {
+    ...headers,
+    ...DEFAULT_PATCH_HEADERS,
+    ...overrides
+  };
+}
+
+export function isAnthropicClaudeModel(model) {
+  if (!isPlainObject(model)) {
+    return false;
+  }
+
+  const providerID = typeof model.providerID === "string" ? model.providerID.toLowerCase() : "";
+  const modelID = typeof model.id === "string" ? model.id.toLowerCase() : "";
+  const api = isPlainObject(model.api) ? model.api : {};
+  const apiID = typeof api.id === "string" ? api.id.toLowerCase() : "";
+  const apiNpm = typeof api.npm === "string" ? api.npm.toLowerCase() : "";
+
+  return (
+    providerID.includes("anthropic") ||
+    modelID.includes("claude") ||
+    apiID.includes("claude") ||
+    apiID.includes("anthropic") ||
+    apiNpm === "@ai-sdk/anthropic" ||
+    apiNpm === "@ai-sdk/google-vertex/anthropic"
+  );
+}
+
+export function isOpenCodeAnthropicPatchTarget(input) {
+  return isPlainObject(input) && isAnthropicClaudeModel(input.model);
+}
+
+export function shouldPatchAnthropicOAuthRequest(url, init = {}) {
+  return isAnthropicMessagesUrl(url) && hasOAuthBearer(init.headers);
+}
+
+export function patchAnthropicOAuthRequest(url, init = {}, options = {}) {
+  if (!shouldPatchAnthropicOAuthRequest(url, init)) {
+    return { url, init, patched: false };
+  }
+
+  const { body, bodyType } = extractBody(init);
+  if (!body || bodyType === "unsupported") {
+    return { url, init, patched: false };
+  }
+
+  const sanitizedBody = sanitizeAnthropicOAuthBody(body, options);
+  const nextInit = { ...init };
+
+  if (bodyType === "json-string") {
+    nextInit.body = JSON.stringify(sanitizedBody);
+  } else {
+    nextInit.body = sanitizedBody;
+  }
+
+  return { url, init: nextInit, patched: true, body: sanitizedBody };
+}
+
+export function createAnthropicOAuthPatchedFetch(fetchImpl, options = {}) {
+  if (typeof fetchImpl !== "function") {
+    throw new TypeError("fetchImpl must be a function");
+  }
+
+  const patchedFetch = async function patchedFetch(url, init = {}) {
+    const patched = patchAnthropicOAuthRequest(url, init, options);
+    return fetchImpl(patched.url, patched.init);
+  };
+
+  patchedFetch[FETCH_PATCH_MARKER] = true;
+  return patchedFetch;
+}
+
+export function installGlobalAnthropicOAuthFetchPatch(options = {}) {
+  if (typeof globalThis.fetch !== "function") {
+    return false;
+  }
+
+  if (globalThis.fetch[FETCH_PATCH_MARKER]) {
+    return false;
+  }
+
+  globalThis.fetch = createAnthropicOAuthPatchedFetch(globalThis.fetch.bind(globalThis), options);
+  return true;
+}
+
+export { DEFAULT_PATCH_HEADERS, DEFAULT_SYSTEM_PREFIX, FETCH_PATCH_MARKER };

package/src/index.d.ts

@@ -0,0 +1,3 @@
+declare const OpenCodeAnthropicOAuthPatch: (...args: any[]) => Promise<Record<string, unknown>>;
+
+export default OpenCodeAnthropicOAuthPatch;

package/src/index.js

@@ -0,0 +1,54 @@
+import {
+  DEFAULT_SYSTEM_PREFIX,
+  installGlobalAnthropicOAuthFetchPatch,
+  isOpenCodeAnthropicPatchTarget,
+  mergePatchHeaders,
+  normalizeAnthropicSystemStrings,
+  sanitizeAnthropicOptions
+} from "./helpers.js";
+
+function getPluginOptions() {
+  return {
+    systemPrefix: process.env.OPENCODE_ANTHROPIC_OAUTH_SYSTEM_PREFIX || DEFAULT_SYSTEM_PREFIX,
+    setClaudeHeaders: process.env.OPENCODE_ANTHROPIC_OAUTH_SET_HEADERS !== "0"
+  };
+}
+
+export default async function OpenCodeAnthropicOAuthPatch() {
+  const pluginOptions = getPluginOptions();
+  installGlobalAnthropicOAuthFetchPatch({
+    ensureClaudeCodeSystem: true,
+    normalizeSystemToUserMessage: true,
+    systemPrefix: pluginOptions.systemPrefix
+  });
+
+  return {
+    async "chat.params"(input, output) {
+      if (!isOpenCodeAnthropicPatchTarget(input)) {
+        return;
+      }
+
+      output.options = sanitizeAnthropicOptions(output.options);
+    },
+
+    async "chat.headers"(input, output) {
+      if (!isOpenCodeAnthropicPatchTarget(input) || !pluginOptions.setClaudeHeaders) {
+        return;
+      }
+
+      output.headers = mergePatchHeaders(output.headers);
+    },
+
+    async "experimental.chat.system.transform"(input, output) {
+      if (!isOpenCodeAnthropicPatchTarget(input)) {
+        return;
+      }
+
+      const nextSystem = normalizeAnthropicSystemStrings(output.system, {
+        systemPrefix: pluginOptions.systemPrefix
+      });
+      output.system.length = 0;
+      output.system.push(...nextSystem);
+    }
+  };
+}