opencode-anthropic-auth 0.0.5 → 0.0.7

package/.github/workflows/publish.yml

@@ -8,6 +8,10 @@ on:
         required: false
         default: "patch"
 
+permissions:
+  id-token: write
+  contents: read
+
 jobs:
   publish:
     runs-on: ubuntu-latest
@@ -16,7 +20,7 @@ jobs:
 
       - uses: actions/setup-node@v4
         with:
-          node-version: "20"
+          node-version: "24"
           registry-url: "https://registry.npmjs.org"
 
       - run: npm install
@@ -24,3 +28,4 @@ jobs:
       - run: npm publish --access public
         env:
           NODE_AUTH_TOKEN: ${{ secrets.NPM_TOKEN }}
+          NPM_CONFIG_PROVENANCE: false

package/index.mjs

@@ -127,34 +127,133 @@ export async function AnthropicAuthPlugin({ client }) {
                 });
                 auth.access = json.access_token;
               }
-              // Add oauth-2025-04-20 beta to whatever betas are already present
-              const incomingBeta = init.headers?.["anthropic-beta"] || "";
+              const requestInit = init ?? {};
+
+              const requestHeaders = new Headers();
+              if (input instanceof Request) {
+                input.headers.forEach((value, key) => {
+                  requestHeaders.set(key, value);
+                });
+              }
+              if (requestInit.headers) {
+                if (requestInit.headers instanceof Headers) {
+                  requestInit.headers.forEach((value, key) => {
+                    requestHeaders.set(key, value);
+                  });
+                } else if (Array.isArray(requestInit.headers)) {
+                  for (const [key, value] of requestInit.headers) {
+                    if (typeof value !== "undefined") {
+                      requestHeaders.set(key, String(value));
+                    }
+                  }
+                } else {
+                  for (const [key, value] of Object.entries(requestInit.headers)) {
+                    if (typeof value !== "undefined") {
+                      requestHeaders.set(key, String(value));
+                    }
+                  }
+                }
+              }
+
+              const incomingBeta = requestHeaders.get("anthropic-beta") || "";
               const incomingBetasList = incomingBeta
                 .split(",")
                 .map((b) => b.trim())
                 .filter(Boolean);
 
-              // Add oauth beta and deduplicate
+              const includeClaudeCode = incomingBetasList.includes(
+                "claude-code-20250219",
+              );
+
               const mergedBetas = [
-                ...new Set([
-                  "oauth-2025-04-20",
-                  "claude-code-20250219",
-                  "interleaved-thinking-2025-05-14",
-                  "fine-grained-tool-streaming-2025-05-14",
-                  ...incomingBetasList,
-                ]),
+                "oauth-2025-04-20",
+                "interleaved-thinking-2025-05-14",
+                ...(includeClaudeCode ? ["claude-code-20250219"] : []),
               ].join(",");
 
-              const headers = {
-                ...init.headers,
-                authorization: `Bearer ${auth.access}`,
-                "anthropic-beta": mergedBetas,
-              };
-              delete headers["x-api-key"];
-              return fetch(input, {
-                ...init,
-                headers,
+              requestHeaders.set("authorization", `Bearer ${auth.access}`);
+              requestHeaders.set("anthropic-beta", mergedBetas);
+              requestHeaders.set(
+                "user-agent",
+                "claude-cli/2.1.2 (external, cli)",
+              );
+              requestHeaders.delete("x-api-key");
+
+              const TOOL_PREFIX = "oc_";
+              let body = requestInit.body;
+              if (body && typeof body === "string") {
+                try {
+                  const parsed = JSON.parse(body);
+                  if (parsed.tools && Array.isArray(parsed.tools)) {
+                    parsed.tools = parsed.tools.map((tool) => ({
+                      ...tool,
+                      name: tool.name ? `${TOOL_PREFIX}${tool.name}` : tool.name,
+                    }));
+                    body = JSON.stringify(parsed);
+                  }
+                } catch (e) {
+                  // ignore parse errors
+                }
+              }
+
+              let requestInput = input;
+              let requestUrl = null;
+              try {
+                if (typeof input === "string" || input instanceof URL) {
+                  requestUrl = new URL(input.toString());
+                } else if (input instanceof Request) {
+                  requestUrl = new URL(input.url);
+                }
+              } catch {
+                requestUrl = null;
+              }
+
+              if (
+                requestUrl &&
+                requestUrl.pathname === "/v1/messages" &&
+                !requestUrl.searchParams.has("beta")
+              ) {
+                requestUrl.searchParams.set("beta", "true");
+                requestInput =
+                  input instanceof Request
+                    ? new Request(requestUrl.toString(), input)
+                    : requestUrl;
+              }
+
+              const response = await fetch(requestInput, {
+                ...requestInit,
+                body,
+                headers: requestHeaders,
               });
+
+              // Transform streaming response to rename tools back
+              if (response.body) {
+                const reader = response.body.getReader();
+                const decoder = new TextDecoder();
+                const encoder = new TextEncoder();
+
+                const stream = new ReadableStream({
+                  async pull(controller) {
+                    const { done, value } = await reader.read();
+                    if (done) {
+                      controller.close();
+                      return;
+                    }
+
+                    let text = decoder.decode(value, { stream: true });
+                    text = text.replace(/"name"\s*:\s*"oc_([^"]+)"/g, '"name": "$1"');
+                    controller.enqueue(encoder.encode(text));
+                  },
+                });
+
+                return new Response(stream, {
+                  status: response.status,
+                  statusText: response.statusText,
+                  headers: response.headers,
+                });
+              }
+
+              return response;
             },
           };
         }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "opencode-anthropic-auth",
-  "version": "0.0.5",
+  "version": "0.0.7",
   "main": "./index.mjs",
   "devDependencies": {
     "@opencode-ai/plugin": "^0.4.45"