@otto-assistant/bridge 0.4.97 → 0.4.101

package/dist/anthropic-auth-plugin.js

@@ -22,71 +22,72 @@
  * - https://github.com/badlogic/pi-mono/blob/main/packages/ai/src/utils/oauth/anthropic.ts
  * - https://github.com/badlogic/pi-mono/blob/main/packages/ai/src/providers/anthropic.ts
  */
-import { loadAccountStore, rememberAnthropicOAuth, rotateAnthropicAccount, saveAccountStore, setAnthropicAuth, shouldRotateAuth, upsertAccount, withAuthStateLock, } from './anthropic-auth-state.js';
-import { extractAnthropicAccountIdentity, } from './anthropic-account-identity.js';
+import { loadAccountStore, rememberAnthropicOAuth, rotateAnthropicAccount, saveAccountStore, setAnthropicAuth, shouldRotateAuth, upsertAccount, withAuthStateLock, } from "./anthropic-auth-state.js";
+import { extractAnthropicAccountIdentity, } from "./anthropic-account-identity.js";
 // PKCE (Proof Key for Code Exchange) using Web Crypto API.
 // Reference: https://github.com/badlogic/pi-mono/blob/main/packages/ai/src/utils/oauth/pkce.ts
 function base64urlEncode(bytes) {
-    let binary = '';
+    let binary = "";
     for (const byte of bytes) {
         binary += String.fromCharCode(byte);
     }
-    return btoa(binary).replace(/\+/g, '-').replace(/\//g, '_').replace(/=/g, '');
+    return btoa(binary).replace(/\+/g, "-").replace(/\//g, "_").replace(/=/g, "");
 }
 async function generatePKCE() {
     const verifierBytes = new Uint8Array(32);
     crypto.getRandomValues(verifierBytes);
     const verifier = base64urlEncode(verifierBytes);
     const data = new TextEncoder().encode(verifier);
-    const hashBuffer = await crypto.subtle.digest('SHA-256', data);
+    const hashBuffer = await crypto.subtle.digest("SHA-256", data);
     const challenge = base64urlEncode(new Uint8Array(hashBuffer));
     return { verifier, challenge };
 }
-import { spawn } from 'node:child_process';
-import { createServer } from 'node:http';
+import { spawn } from "node:child_process";
+import { createServer } from "node:http";
 // --- Constants ---
 const CLIENT_ID = (() => {
-    const encoded = 'OWQxYzI1MGEtZTYxYi00NGQ5LTg4ZWQtNTk0NGQxOTYyZjVl';
-    return typeof atob === 'function'
+    const encoded = "OWQxYzI1MGEtZTYxYi00NGQ5LTg4ZWQtNTk0NGQxOTYyZjVl";
+    return typeof atob === "function"
         ? atob(encoded)
-        : Buffer.from(encoded, 'base64').toString('utf8');
+        : Buffer.from(encoded, "base64").toString("utf8");
 })();
-const TOKEN_URL = 'https://platform.claude.com/v1/oauth/token';
-const CREATE_API_KEY_URL = 'https://api.anthropic.com/api/oauth/claude_cli/create_api_key';
-const CLIENT_DATA_URL = 'https://api.anthropic.com/api/oauth/claude_cli/client_data';
-const PROFILE_URL = 'https://api.anthropic.com/api/oauth/profile';
+const TOKEN_URL = "https://platform.claude.com/v1/oauth/token";
+const CREATE_API_KEY_URL = "https://api.anthropic.com/api/oauth/claude_cli/create_api_key";
+const CLIENT_DATA_URL = "https://api.anthropic.com/api/oauth/claude_cli/client_data";
+const PROFILE_URL = "https://api.anthropic.com/api/oauth/profile";
 const CALLBACK_PORT = 53692;
-const CALLBACK_PATH = '/callback';
+const CALLBACK_PATH = "/callback";
 const REDIRECT_URI = `http://localhost:${CALLBACK_PORT}${CALLBACK_PATH}`;
-const SCOPES = 'org:create_api_key user:profile user:inference user:sessions:claude_code user:mcp_servers user:file_upload';
+const SCOPES = "org:create_api_key user:profile user:inference user:sessions:claude_code user:mcp_servers user:file_upload";
 const OAUTH_TIMEOUT_MS = 5 * 60 * 1000;
-const CLAUDE_CODE_VERSION = '2.1.75';
+const CLAUDE_CODE_VERSION = "2.1.75";
 const CLAUDE_CODE_IDENTITY = "You are Claude Code, Anthropic's official CLI for Claude.";
-const OPENCODE_IDENTITY = 'You are OpenCode, the best coding agent on the planet.';
-const CLAUDE_CODE_BETA = 'claude-code-20250219';
-const OAUTH_BETA = 'oauth-2025-04-20';
-const FINE_GRAINED_TOOL_STREAMING_BETA = 'fine-grained-tool-streaming-2025-05-14';
-const INTERLEAVED_THINKING_BETA = 'interleaved-thinking-2025-05-14';
-const TOAST_SESSION_HEADER = 'x-kimaki-session-id';
+const OPENCODE_IDENTITY = "You are OpenCode, the best coding agent on the planet.";
+const ANTHROPIC_PROMPT_MARKER = "Skills provide specialized instructions";
+const CLAUDE_CODE_BETA = "claude-code-20250219";
+const OAUTH_BETA = "oauth-2025-04-20";
+const FINE_GRAINED_TOOL_STREAMING_BETA = "fine-grained-tool-streaming-2025-05-14";
+const INTERLEAVED_THINKING_BETA = "interleaved-thinking-2025-05-14";
+const TOAST_SESSION_HEADER = "x-kimaki-session-id";
 const ANTHROPIC_HOSTS = new Set([
-    'api.anthropic.com',
-    'claude.ai',
-    'console.anthropic.com',
-    'platform.claude.com',
+    "api.anthropic.com",
+    "claude.ai",
+    "console.anthropic.com",
+    "platform.claude.com",
 ]);
 const OPENCODE_TO_CLAUDE_CODE_TOOL_NAME = {
-    bash: 'Bash',
-    edit: 'Edit',
-    glob: 'Glob',
-    grep: 'Grep',
-    question: 'AskUserQuestion',
-    read: 'Read',
-    skill: 'Skill',
-    task: 'Task',
-    todowrite: 'TodoWrite',
-    webfetch: 'WebFetch',
-    websearch: 'WebSearch',
-    write: 'Write',
+    bash: "Bash",
+    edit: "Edit",
+    glob: "Glob",
+    grep: "Grep",
+    question: "AskUserQuestion",
+    read: "Read",
+    skill: "Skill",
+    task: "Task",
+    todowrite: "TodoWrite",
+    webfetch: "WebFetch",
+    websearch: "WebSearch",
+    write: "Write",
 };
 // --- HTTP helpers ---
 // Claude OAuth token exchange can 429 when this runs inside the opencode auth
@@ -101,8 +102,8 @@ async function requestText(urlString, options) {
             method: options.method,
             url: urlString,
         });
-        const child = spawn('node', [
-            '-e',
+        const child = spawn("node", [
+            "-e",
             `
 const input = JSON.parse(process.argv[1]);
 (async () => {
@@ -124,32 +125,32 @@ const input = JSON.parse(process.argv[1]);
     `.trim(),
             payload,
         ], {
-            stdio: ['ignore', 'pipe', 'pipe'],
+            stdio: ["ignore", "pipe", "pipe"],
         });
-        let stdout = '';
-        let stderr = '';
+        let stdout = "";
+        let stderr = "";
         const timeout = setTimeout(() => {
             child.kill();
             reject(new Error(`Request timed out. url=${urlString}`));
         }, 30_000);
-        child.stdout.on('data', (chunk) => {
+        child.stdout.on("data", (chunk) => {
             stdout += String(chunk);
         });
-        child.stderr.on('data', (chunk) => {
+        child.stderr.on("data", (chunk) => {
             stderr += String(chunk);
         });
-        child.on('error', (error) => {
+        child.on("error", (error) => {
             clearTimeout(timeout);
             reject(error);
         });
-        child.on('close', (code) => {
+        child.on("close", (code) => {
             clearTimeout(timeout);
             if (code !== 0) {
                 let details = stderr.trim();
                 try {
                     const parsed = JSON.parse(details);
-                    if (typeof parsed.status === 'number') {
-                        reject(new Error(`HTTP ${parsed.status} from ${urlString}: ${parsed.body ?? ''}`));
+                    if (typeof parsed.status === "number") {
+                        reject(new Error(`HTTP ${parsed.status} from ${urlString}: ${parsed.body ?? ""}`));
                         return;
                     }
                 }
@@ -166,11 +167,11 @@ const input = JSON.parse(process.argv[1]);
 async function postJson(url, body) {
     const requestBody = JSON.stringify(body);
     const responseText = await requestText(url, {
-        method: 'POST',
+        method: "POST",
         headers: {
-            Accept: 'application/json',
-            'Content-Length': String(Buffer.byteLength(requestBody)),
-            'Content-Type': 'application/json',
+            Accept: "application/json",
+            "Content-Length": String(Buffer.byteLength(requestBody)),
+            "Content-Type": "application/json",
         },
         body: requestBody,
     });
@@ -190,7 +191,7 @@ function tokenExpiry(expiresIn) {
 }
 async function exchangeAuthorizationCode(code, state, verifier, redirectUri) {
     const json = await postJson(TOKEN_URL, {
-        grant_type: 'authorization_code',
+        grant_type: "authorization_code",
         client_id: CLIENT_ID,
         code,
         state,
@@ -199,7 +200,7 @@ async function exchangeAuthorizationCode(code, state, verifier, redirectUri) {
     });
     const data = parseTokenResponse(json);
     return {
-        type: 'success',
+        type: "success",
         refresh: data.refresh_token,
         access: data.access_token,
         expires: tokenExpiry(data.expires_in),
@@ -207,13 +208,13 @@ async function exchangeAuthorizationCode(code, state, verifier, redirectUri) {
 }
 async function refreshAnthropicToken(refreshToken) {
     const json = await postJson(TOKEN_URL, {
-        grant_type: 'refresh_token',
+        grant_type: "refresh_token",
         client_id: CLIENT_ID,
         refresh_token: refreshToken,
     });
     const data = parseTokenResponse(json);
     return {
-        type: 'oauth',
+        type: "oauth",
         refresh: data.refresh_token,
         access: data.access_token,
         expires: tokenExpiry(data.expires_in),
@@ -221,26 +222,27 @@ async function refreshAnthropicToken(refreshToken) {
 }
 async function createApiKey(accessToken) {
     const responseText = await requestText(CREATE_API_KEY_URL, {
-        method: 'POST',
+        method: "POST",
         headers: {
-            Accept: 'application/json',
+            Accept: "application/json",
             authorization: `Bearer ${accessToken}`,
-            'Content-Type': 'application/json',
+            "Content-Type": "application/json",
         },
     });
     const json = JSON.parse(responseText);
-    return { type: 'success', key: json.raw_key };
+    return { type: "success", key: json.raw_key };
 }
 async function fetchAnthropicAccountIdentity(accessToken) {
     const urls = [CLIENT_DATA_URL, PROFILE_URL];
     for (const url of urls) {
         const responseText = await requestText(url, {
-            method: 'GET',
+            method: "GET",
             headers: {
-                Accept: 'application/json',
+                Accept: "application/json",
                 authorization: `Bearer ${accessToken}`,
-                'user-agent': process.env.OPENCODE_ANTHROPIC_USER_AGENT || `claude-cli/${CLAUDE_CODE_VERSION}`,
-                'x-app': 'cli',
+                "user-agent": process.env.OPENCODE_ANTHROPIC_USER_AGENT ||
+                    `claude-cli/${CLAUDE_CODE_VERSION}`,
+                "x-app": "cli",
             },
         }).catch(() => {
             return undefined;
@@ -268,29 +270,31 @@ async function startCallbackServer(expectedState) {
         });
         const server = createServer((req, res) => {
             try {
-                const url = new URL(req.url || '', 'http://localhost');
+                const url = new URL(req.url || "", "http://localhost");
                 if (url.pathname !== CALLBACK_PATH) {
-                    res.writeHead(404).end('Not found');
+                    res.writeHead(404).end("Not found");
                     return;
                 }
-                const code = url.searchParams.get('code');
-                const state = url.searchParams.get('state');
-                const error = url.searchParams.get('error');
+                const code = url.searchParams.get("code");
+                const state = url.searchParams.get("state");
+                const error = url.searchParams.get("error");
                 if (error || !code || !state || state !== expectedState) {
-                    res.writeHead(400).end('Authentication failed: ' + (error || 'missing code/state'));
+                    res
+                        .writeHead(400)
+                        .end("Authentication failed: " + (error || "missing code/state"));
                     return;
                 }
                 res
-                    .writeHead(200, { 'Content-Type': 'text/plain' })
-                    .end('Authentication successful. You can close this window.');
+                    .writeHead(200, { "Content-Type": "text/plain" })
+                    .end("Authentication successful. You can close this window.");
                 settle?.({ code, state });
             }
             catch {
-                res.writeHead(500).end('Internal error');
+                res.writeHead(500).end("Internal error");
             }
         });
-        server.once('error', reject);
-        server.listen(CALLBACK_PORT, '127.0.0.1', () => {
+        server.once("error", reject);
+        server.listen(CALLBACK_PORT, "127.0.0.1", () => {
             resolve({
                 server,
                 cancelWait: () => {
@@ -315,13 +319,13 @@ async function beginAuthorizationFlow() {
     const pkce = await generatePKCE();
     const callbackServer = await startCallbackServer(pkce.verifier);
     const authParams = new URLSearchParams({
-        code: 'true',
+        code: "true",
         client_id: CLIENT_ID,
-        response_type: 'code',
+        response_type: "code",
         redirect_uri: REDIRECT_URI,
         scope: SCOPES,
         code_challenge: pkce.challenge,
-        code_challenge_method: 'S256',
+        code_challenge_method: "S256",
         state: pkce.verifier,
     });
     return {
@@ -358,7 +362,7 @@ async function waitForCallback(callbackServer, manualInput) {
             }),
         ]);
         if (!result?.code) {
-            throw new Error('Timed out waiting for OAuth callback');
+            throw new Error("Timed out waiting for OAuth callback");
         }
         return result;
     }
@@ -370,25 +374,25 @@ async function waitForCallback(callbackServer, manualInput) {
 function parseManualInput(input) {
     try {
         const url = new URL(input);
-        const code = url.searchParams.get('code');
-        const state = url.searchParams.get('state');
+        const code = url.searchParams.get("code");
+        const state = url.searchParams.get("state");
         if (code)
-            return { code, state: state || '' };
+            return { code, state: state || "" };
     }
     catch {
         // not a URL
     }
-    if (input.includes('#')) {
-        const [code = '', state = ''] = input.split('#', 2);
+    if (input.includes("#")) {
+        const [code = "", state = ""] = input.split("#", 2);
         return { code, state };
     }
-    if (input.includes('code=')) {
+    if (input.includes("code=")) {
         const params = new URLSearchParams(input);
-        const code = params.get('code');
+        const code = params.get("code");
         if (code)
-            return { code, state: params.get('state') || '' };
+            return { code, state: params.get("state") || "" };
     }
-    return { code: input, state: '' };
+    return { code: input, state: "" };
 }
 // Unified authorize handler: returns either OAuth tokens or an API key,
 // for both auto and remote-first modes.
@@ -400,12 +404,12 @@ function buildAuthorizeHandler(mode) {
         const finalize = async (result) => {
             const verifier = auth.verifier;
             const creds = await exchangeAuthorizationCode(result.code, result.state || verifier, verifier, REDIRECT_URI);
-            if (mode === 'apikey') {
+            if (mode === "apikey") {
                 return createApiKey(creds.access);
             }
             const identity = await fetchAnthropicAccountIdentity(creds.access);
             await rememberAnthropicOAuth({
-                type: 'oauth',
+                type: "oauth",
                 refresh: creds.refresh,
                 access: creds.access,
                 expires: creds.expires,
@@ -415,8 +419,8 @@ function buildAuthorizeHandler(mode) {
         if (!isRemote) {
             return {
                 url: auth.url,
-                instructions: 'Complete login in your browser on this machine. OpenCode will catch the localhost callback automatically.',
-                method: 'auto',
+                instructions: "Complete login in your browser on this machine. OpenCode will catch the localhost callback automatically.",
+                method: "auto",
                 callback: async () => {
                     pendingAuthResult ??= (async () => {
                         try {
@@ -424,7 +428,7 @@ function buildAuthorizeHandler(mode) {
                             return await finalize(result);
                         }
                         catch {
-                            return { type: 'failed' };
+                            return { type: "failed" };
                         }
                     })();
                     return pendingAuthResult;
@@ -433,8 +437,8 @@ function buildAuthorizeHandler(mode) {
         }
         return {
             url: auth.url,
-            instructions: 'Complete login in your browser, then paste the final redirect URL from the address bar here. Pasting just the authorization code also works.',
-            method: 'code',
+            instructions: "Complete login in your browser, then paste the final redirect URL from the address bar here. Pasting just the authorization code also works.",
+            method: "code",
             callback: async (input) => {
                 pendingAuthResult ??= (async () => {
                     try {
@@ -442,7 +446,7 @@ function buildAuthorizeHandler(mode) {
                         return await finalize(result);
                     }
                     catch {
-                        return { type: 'failed' };
+                        return { type: "failed" };
                     }
                 })();
                 return pendingAuthResult;
@@ -456,46 +460,56 @@ function buildAuthorizeHandler(mode) {
 function toClaudeCodeToolName(name) {
     return OPENCODE_TO_CLAUDE_CODE_TOOL_NAME[name.toLowerCase()] ?? name;
 }
-function sanitizeSystemText(text, onError) {
+function sanitizeAnthropicSystemText(text, onError) {
     const startIdx = text.indexOf(OPENCODE_IDENTITY);
     if (startIdx === -1)
         return text;
-    const codeRefsMarker = '# Code References';
-    const endIdx = text.indexOf(codeRefsMarker, startIdx);
+    // Keep the marker aligned with the current OpenCode Anthropic prompt.
+    const endIdx = text.indexOf(ANTHROPIC_PROMPT_MARKER, startIdx);
     if (endIdx === -1) {
-        onError?.(`sanitizeSystemText: could not find '# Code References' after OpenCode identity`);
+        onError?.("sanitizeAnthropicSystemText: could not find Anthropic prompt marker after OpenCode identity");
         return text;
     }
-    // Remove everything from the OpenCode identity up to (but not including) '# Code References'
-    return text.slice(0, startIdx) + text.slice(endIdx);
+    return (text.slice(0, startIdx) + text.slice(endIdx)).replaceAll("opencode", "openc0de");
+}
+function mapSystemTextPart(part, onError) {
+    if (typeof part === "string") {
+        return { type: "text", text: sanitizeAnthropicSystemText(part, onError) };
+    }
+    if (part &&
+        typeof part === "object" &&
+        "type" in part &&
+        part.type === "text" &&
+        "text" in part &&
+        typeof part.text === "string") {
+        return {
+            ...part,
+            text: sanitizeAnthropicSystemText(part.text, onError),
+        };
+    }
+    return part;
 }
 function prependClaudeCodeIdentity(system, onError) {
-    const identityBlock = { type: 'text', text: CLAUDE_CODE_IDENTITY };
-    if (typeof system === 'undefined')
+    const identityBlock = { type: "text", text: CLAUDE_CODE_IDENTITY };
+    if (typeof system === "undefined")
         return [identityBlock];
-    if (typeof system === 'string') {
-        const sanitized = sanitizeSystemText(system, onError);
+    if (typeof system === "string") {
+        const sanitized = sanitizeAnthropicSystemText(system, onError);
         if (sanitized === CLAUDE_CODE_IDENTITY)
             return [identityBlock];
-        return [identityBlock, { type: 'text', text: sanitized }];
+        return [identityBlock, { type: "text", text: sanitized }];
     }
     if (!Array.isArray(system))
         return [identityBlock, system];
     const sanitized = system.map((item) => {
-        if (typeof item === 'string')
-            return { type: 'text', text: sanitizeSystemText(item, onError) };
-        if (item && typeof item === 'object' && item.type === 'text') {
-            const text = item.text;
-            if (typeof text === 'string') {
-                return { ...item, text: sanitizeSystemText(text, onError) };
-            }
-        }
-        return item;
+        return mapSystemTextPart(item, onError);
     });
     const first = sanitized[0];
     if (first &&
-        typeof first === 'object' &&
-        first.type === 'text' &&
+        typeof first === "object" &&
+        "type" in first &&
+        first.type === "text" &&
+        "text" in first &&
         first.text === CLAUDE_CODE_IDENTITY) {
         return sanitized;
     }
@@ -503,18 +517,22 @@ function prependClaudeCodeIdentity(system, onError) {
 }
 function rewriteRequestPayload(body, onError) {
     if (!body)
-        return { body, modelId: undefined, reverseToolNameMap: new Map() };
+        return {
+            body,
+            modelId: undefined,
+            reverseToolNameMap: new Map(),
+        };
     try {
         const payload = JSON.parse(body);
         const reverseToolNameMap = new Map();
-        const modelId = typeof payload.model === 'string' ? payload.model : undefined;
+        const modelId = typeof payload.model === "string" ? payload.model : undefined;
         // Build reverse map and rename tools
         if (Array.isArray(payload.tools)) {
             payload.tools = payload.tools.map((tool) => {
-                if (!tool || typeof tool !== 'object')
+                if (!tool || typeof tool !== "object")
                     return tool;
                 const name = tool.name;
-                if (typeof name !== 'string')
+                if (typeof name !== "string")
                     return tool;
                 const mapped = toClaudeCodeToolName(name);
                 reverseToolNameMap.set(mapped, name);
@@ -525,10 +543,10 @@ function rewriteRequestPayload(body, onError) {
         payload.system = prependClaudeCodeIdentity(payload.system, onError);
         // Rename tool_choice
         if (payload.tool_choice &&
-            typeof payload.tool_choice === 'object' &&
-            payload.tool_choice.type === 'tool') {
+            typeof payload.tool_choice === "object" &&
+            payload.tool_choice.type === "tool") {
             const name = payload.tool_choice.name;
-            if (typeof name === 'string') {
+            if (typeof name === "string") {
                 payload.tool_choice = {
                     ...payload.tool_choice,
                     name: toClaudeCodeToolName(name),
@@ -538,7 +556,7 @@ function rewriteRequestPayload(body, onError) {
         // Rename tool_use blocks in messages
         if (Array.isArray(payload.messages)) {
             payload.messages = payload.messages.map((message) => {
-                if (!message || typeof message !== 'object')
+                if (!message || typeof message !== "object")
                     return message;
                 const content = message.content;
                 if (!Array.isArray(content))
@@ -546,12 +564,15 @@ function rewriteRequestPayload(body, onError) {
                 return {
                     ...message,
                     content: content.map((block) => {
-                        if (!block || typeof block !== 'object')
+                        if (!block || typeof block !== "object")
                             return block;
                         const b = block;
-                        if (b.type !== 'tool_use' || typeof b.name !== 'string')
+                        if (b.type !== "tool_use" || typeof b.name !== "string")
                             return block;
-                        return { ...block, name: toClaudeCodeToolName(b.name) };
+                        return {
+                            ...block,
+                            name: toClaudeCodeToolName(b.name),
+                        };
                     }),
                 };
             });
@@ -559,7 +580,11 @@ function rewriteRequestPayload(body, onError) {
         return { body: JSON.stringify(payload), modelId, reverseToolNameMap };
     }
     catch {
-        return { body, modelId: undefined, reverseToolNameMap: new Map() };
+        return {
+            body,
+            modelId: undefined,
+            reverseToolNameMap: new Map(),
+        };
     }
 }
 function wrapResponseStream(response, reverseToolNameMap) {
@@ -568,7 +593,7 @@ function wrapResponseStream(response, reverseToolNameMap) {
     const reader = response.body.getReader();
     const decoder = new TextDecoder();
     const encoder = new TextEncoder();
-    let carry = '';
+    let carry = "";
     const transform = (text) => {
         return text.replace(/"name"\s*:\s*"([^"]+)"/g, (full, name) => {
             const original = reverseToolNameMap.get(name);
@@ -611,11 +636,15 @@ function appendToastSessionMarker({ message, sessionId, }) {
 }
 // --- Beta headers ---
 function getRequiredBetas(modelId) {
-    const betas = [CLAUDE_CODE_BETA, OAUTH_BETA, FINE_GRAINED_TOOL_STREAMING_BETA];
-    const isAdaptive = modelId?.includes('opus-4-6') ||
-        modelId?.includes('opus-4.6') ||
-        modelId?.includes('sonnet-4-6') ||
-        modelId?.includes('sonnet-4.6');
+    const betas = [
+        CLAUDE_CODE_BETA,
+        OAUTH_BETA,
+        FINE_GRAINED_TOOL_STREAMING_BETA,
+    ];
+    const isAdaptive = modelId?.includes("opus-4-6") ||
+        modelId?.includes("opus-4.6") ||
+        modelId?.includes("sonnet-4-6") ||
+        modelId?.includes("sonnet-4.6");
     if (!isAdaptive)
         betas.push(INTERLEAVED_THINKING_BETA);
     return betas;
@@ -624,16 +653,16 @@ function mergeBetas(existing, required) {
     return [
         ...new Set([
             ...required,
-            ...(existing || '')
-                .split(',')
+            ...(existing || "")
+                .split(",")
                 .map((s) => s.trim())
                 .filter(Boolean),
         ]),
-    ].join(',');
+    ].join(",");
 }
 // --- Token refresh with dedup ---
 function isOAuthStored(auth) {
-    return auth.type === 'oauth';
+    return auth.type === "oauth";
 }
 async function getFreshOAuth(getAuth, client) {
     const auth = await getAuth();
@@ -648,7 +677,7 @@ async function getFreshOAuth(getAuth, client) {
     const refreshPromise = withAuthStateLock(async () => {
         const latest = await getAuth();
         if (!isOAuthStored(latest)) {
-            throw new Error('Anthropic OAuth credentials disappeared during refresh');
+            throw new Error("Anthropic OAuth credentials disappeared during refresh");
         }
         if (latest.access && latest.expires > Date.now())
             return latest;
@@ -658,7 +687,8 @@ async function getFreshOAuth(getAuth, client) {
         if (store.accounts.length > 0) {
             const identity = (() => {
                 const currentIndex = store.accounts.findIndex((account) => {
-                    return account.refresh === latest.refresh || account.access === latest.access;
+                    return (account.refresh === latest.refresh ||
+                        account.access === latest.access);
                 });
                 const current = currentIndex >= 0 ? store.accounts[currentIndex] : undefined;
                 if (!current)
@@ -678,27 +708,26 @@ async function getFreshOAuth(getAuth, client) {
         pendingRefresh.delete(auth.refresh);
     });
 }
-// --- Plugin export ---
 const AnthropicAuthPlugin = async ({ client }) => {
     return {
-        'chat.headers': async (input, output) => {
-            if (input.model.providerID !== 'anthropic') {
+        "chat.headers": async (input, output) => {
+            if (input.model.providerID !== "anthropic") {
                 return;
             }
             output.headers[TOAST_SESSION_HEADER] = input.sessionID;
         },
         auth: {
-            provider: 'anthropic',
+            provider: "anthropic",
             async loader(getAuth, provider) {
                 const auth = await getAuth();
-                if (auth.type !== 'oauth')
+                if (auth.type !== "oauth")
                     return {};
                 // Zero out costs for OAuth users (Claude Pro/Max subscription)
                 for (const model of Object.values(provider.models)) {
                     model.cost = { input: 0, output: 0, cache: { read: 0, write: 0 } };
                 }
                 return {
-                    apiKey: '',
+                    apiKey: "",
                     async fetch(input, init) {
                         const url = (() => {
                             try {
@@ -710,7 +739,7 @@ const AnthropicAuthPlugin = async ({ client }) => {
                         })();
                         if (!url || !ANTHROPIC_HOSTS.has(url.hostname))
                             return fetch(input, init);
-                        const originalBody = typeof init?.body === 'string'
+                        const originalBody = typeof init?.body === "string"
                             ? init.body
                             : input instanceof Request
                                 ? await input
@@ -727,24 +756,30 @@ const AnthropicAuthPlugin = async ({ client }) => {
                         }
                         const sessionId = headers.get(TOAST_SESSION_HEADER) ?? undefined;
                         const rewritten = rewriteRequestPayload(originalBody, (msg) => {
-                            client.tui.showToast({
+                            client.tui
+                                .showToast({
                                 body: {
-                                    message: appendToastSessionMarker({ message: msg, sessionId }),
-                                    variant: 'error',
+                                    message: appendToastSessionMarker({
+                                        message: msg,
+                                        sessionId,
+                                    }),
+                                    variant: "error",
                                 },
-                            }).catch(() => { });
+                            })
+                                .catch(() => { });
                         });
                         const betas = getRequiredBetas(rewritten.modelId);
                         const runRequest = async (auth) => {
                             const requestHeaders = new Headers(headers);
                             requestHeaders.delete(TOAST_SESSION_HEADER);
-                            requestHeaders.set('accept', 'application/json');
-                            requestHeaders.set('anthropic-beta', mergeBetas(requestHeaders.get('anthropic-beta'), betas));
-                            requestHeaders.set('anthropic-dangerous-direct-browser-access', 'true');
-                            requestHeaders.set('authorization', `Bearer ${auth.access}`);
-                            requestHeaders.set('user-agent', process.env.OPENCODE_ANTHROPIC_USER_AGENT || `claude-cli/${CLAUDE_CODE_VERSION}`);
-                            requestHeaders.set('x-app', 'cli');
-                            requestHeaders.delete('x-api-key');
+                            requestHeaders.set("accept", "application/json");
+                            requestHeaders.set("anthropic-beta", mergeBetas(requestHeaders.get("anthropic-beta"), betas));
+                            requestHeaders.set("anthropic-dangerous-direct-browser-access", "true");
+                            requestHeaders.set("authorization", `Bearer ${auth.access}`);
+                            requestHeaders.set("user-agent", process.env.OPENCODE_ANTHROPIC_USER_AGENT ||
+                                `claude-cli/${CLAUDE_CODE_VERSION}`);
+                            requestHeaders.set("x-app", "cli");
+                            requestHeaders.delete("x-api-key");
                             return fetch(input, {
                                 ...(init ?? {}),
                                 body: rewritten.body,
@@ -759,20 +794,22 @@ const AnthropicAuthPlugin = async ({ client }) => {
                             const bodyText = await response
                                 .clone()
                                 .text()
-                                .catch(() => '');
+                                .catch(() => "");
                             if (shouldRotateAuth(response.status, bodyText)) {
                                 const rotated = await rotateAnthropicAccount(freshAuth, client);
                                 if (rotated) {
                                     // Show toast notification so Discord thread shows the rotation
-                                    client.tui.showToast({
+                                    client.tui
+                                        .showToast({
                                         body: {
                                             message: appendToastSessionMarker({
                                                 message: `Switching from account ${rotated.fromLabel} to account ${rotated.toLabel}`,
                                                 sessionId,
                                             }),
-                                            variant: 'info',
+                                            variant: "info",
                                         },
-                                    }).catch(() => { });
+                                    })
+                                        .catch(() => { });
                                     const retryAuth = await getFreshOAuth(getAuth, client);
                                     if (retryAuth) {
                                         response = await runRequest(retryAuth);
@@ -786,22 +823,36 @@ const AnthropicAuthPlugin = async ({ client }) => {
             },
             methods: [
                 {
-                    label: 'Claude Pro/Max',
-                    type: 'oauth',
-                    authorize: buildAuthorizeHandler('oauth'),
+                    label: "Claude Pro/Max",
+                    type: "oauth",
+                    authorize: buildAuthorizeHandler("oauth"),
                 },
                 {
-                    label: 'Create an API Key',
-                    type: 'oauth',
-                    authorize: buildAuthorizeHandler('apikey'),
+                    label: "Create an API Key",
+                    type: "oauth",
+                    authorize: buildAuthorizeHandler("apikey"),
                 },
                 {
-                    provider: 'anthropic',
-                    label: 'Manually enter API Key',
-                    type: 'api',
+                    provider: "anthropic",
+                    label: "Manually enter API Key",
+                    type: "api",
                 },
             ],
         },
     };
 };
-export { AnthropicAuthPlugin as anthropicAuthPlugin, };
+const replacer = async () => {
+    return {
+        "experimental.chat.system.transform": (async (input, output) => {
+            if (input.model.providerID !== "anthropic")
+                return;
+            const textIndex = output.system.findIndex((x) => x.includes(OPENCODE_IDENTITY));
+            const text = output.system[textIndex];
+            if (!text) {
+                return;
+            }
+            output.system[textIndex] = sanitizeAnthropicSystemText(text);
+        }),
+    };
+};
+export { replacer, AnthropicAuthPlugin as anthropicAuthPlugin };