@xtruder/opencode-claude-max-plugin 0.1.17 → 0.2.2

package/build/server.js

@@ -0,0 +1,1212 @@
+// src/usage.ts
+import {
+  closeSync,
+  constants as fsConstants,
+  mkdirSync,
+  openSync,
+  readFileSync as readFileSync2,
+  renameSync,
+  unlinkSync,
+  writeFileSync
+} from "node:fs";
+import { homedir as homedir2 } from "node:os";
+import { join as join2 } from "node:path";
+
+// src/credentials.ts
+import { existsSync, readFileSync } from "node:fs";
+import { execSync } from "node:child_process";
+import { homedir } from "node:os";
+import { join } from "node:path";
+var CREDENTIAL_CACHE_TTL_MS = 30000;
+var EXPIRY_BUFFER_MS = 60000;
+var cachedCreds = null;
+var cachedAt = 0;
+var cachedPath;
+function getCredentialsPath() {
+  return join(homedir(), ".claude", ".credentials.json");
+}
+function readClaudeCredentials(path) {
+  const credPath = path ?? getCredentialsPath();
+  if (!existsSync(credPath))
+    return null;
+  try {
+    const raw = readFileSync(credPath, "utf-8");
+    const parsed = JSON.parse(raw);
+    if (!parsed.claudeAiOauth?.accessToken)
+      return null;
+    return parsed.claudeAiOauth;
+  } catch {
+    return null;
+  }
+}
+function isExpired(creds) {
+  return Date.now() > creds.expiresAt - EXPIRY_BUFFER_MS;
+}
+function refreshViaCli() {
+  const maxAttempts = 2;
+  for (let i = 0;i < maxAttempts; i++) {
+    try {
+      execSync("claude -p . --model haiku", {
+        timeout: 60000,
+        encoding: "utf-8",
+        env: { ...process.env, TERM: "dumb" },
+        stdio: "ignore"
+      });
+      return true;
+    } catch {}
+  }
+  return false;
+}
+function refreshIfNeeded(path) {
+  const creds = readClaudeCredentials(path);
+  if (!creds)
+    return null;
+  if (!isExpired(creds))
+    return creds;
+  console.warn("[anthropic-sdk-provider] OAuth token near expiry, refreshing via Claude CLI...");
+  const refreshed = refreshViaCli();
+  if (!refreshed) {
+    console.warn("[anthropic-sdk-provider] CLI refresh failed. Token may be expired.");
+    return creds;
+  }
+  const fresh = readClaudeCredentials(path);
+  if (fresh && !isExpired(fresh)) {
+    console.warn("[anthropic-sdk-provider] Token refreshed successfully.");
+    return fresh;
+  }
+  return fresh ?? creds;
+}
+function getCachedCredentials(path) {
+  const now = Date.now();
+  const resolvedPath = path ?? cachedPath;
+  if (cachedCreds && now - cachedAt < CREDENTIAL_CACHE_TTL_MS && !isExpired(cachedCreds)) {
+    return cachedCreds;
+  }
+  const fresh = refreshIfNeeded(resolvedPath);
+  if (fresh) {
+    cachedCreds = fresh;
+    cachedAt = now;
+    cachedPath = resolvedPath;
+  } else {
+    cachedCreds = null;
+  }
+  return cachedCreds;
+}
+
+// src/usage.ts
+var cachedUsage = {};
+var XDG_STATE = process.env.XDG_STATE_HOME || join2(homedir2(), ".local", "state");
+var USAGE_CACHE_DIR = join2(XDG_STATE, "opencode");
+var USAGE_CACHE_FILE = join2(USAGE_CACHE_DIR, "usage-cache.json");
+function emptyCache() {
+  return { api: null, headers: null, updatedAt: 0, apiFetchedAt: 0, apiRateLimitUntil: 0 };
+}
+var USAGE_LOCK_FILE = USAGE_CACHE_FILE + ".lock";
+var USAGE_TMP_FILE = USAGE_CACHE_FILE + ".tmp";
+var LOCK_STALE_MS = 5000;
+function acquireLock() {
+  try {
+    mkdirSync(USAGE_CACHE_DIR, { recursive: true });
+    const fd = openSync(USAGE_LOCK_FILE, fsConstants.O_CREAT | fsConstants.O_EXCL | fsConstants.O_WRONLY);
+    writeFileSync(fd, `${process.pid}
+${Date.now()}`);
+    closeSync(fd);
+    return true;
+  } catch (err) {
+    if (err?.code !== "EEXIST")
+      return false;
+    try {
+      const text = readFileSync2(USAGE_LOCK_FILE, "utf-8");
+      const ts = parseInt(text.split(`
+`)[1] ?? "0");
+      if (Date.now() - ts > LOCK_STALE_MS) {
+        unlinkSync(USAGE_LOCK_FILE);
+        return acquireLock();
+      }
+    } catch {
+      try {
+        unlinkSync(USAGE_LOCK_FILE);
+      } catch {}
+      return acquireLock();
+    }
+    return false;
+  }
+}
+function releaseLock() {
+  try {
+    unlinkSync(USAGE_LOCK_FILE);
+  } catch {}
+}
+function readUsageCache() {
+  try {
+    const text = readFileSync2(USAGE_CACHE_FILE, "utf-8");
+    const data = JSON.parse(text);
+    if (data && typeof data.updatedAt === "number")
+      return data;
+  } catch {}
+  return emptyCache();
+}
+function writeUsageCache(update) {
+  if (!acquireLock())
+    return;
+  try {
+    const existing = readUsageCache();
+    const merged = {
+      ...existing,
+      ...update,
+      updatedAt: Date.now()
+    };
+    mkdirSync(USAGE_CACHE_DIR, { recursive: true });
+    writeFileSync(USAGE_TMP_FILE, JSON.stringify(merged));
+    renameSync(USAGE_TMP_FILE, USAGE_CACHE_FILE);
+  } catch {
+    try {
+      unlinkSync(USAGE_TMP_FILE);
+    } catch {}
+  } finally {
+    releaseLock();
+  }
+}
+function persistCachedUsage() {
+  if (cachedUsage.fiveHourUtil == null && cachedUsage.sevenDayUtil == null)
+    return;
+  writeUsageCache({ headers: { ...cachedUsage } });
+}
+var API_TTL_MS = 5 * 60000;
+
+// src/cch.ts
+import xxhashInit from "xxhash-wasm";
+var CCH_SEED = 0x6e52736ac806831en;
+var CCH_PLACEHOLDER = "cch=00000";
+var CCH_MASK = 0xfffffn;
+var hasherPromise = null;
+function getHasher() {
+  if (!hasherPromise) {
+    hasherPromise = xxhashInit();
+  }
+  return hasherPromise;
+}
+async function computeCch(body) {
+  const hasher = await getHasher();
+  const hash = hasher.h64Raw(new TextEncoder().encode(body), CCH_SEED);
+  return (hash & CCH_MASK).toString(16).padStart(5, "0");
+}
+function replaceCchPlaceholder(body, cch) {
+  return body.replace(CCH_PLACEHOLDER, `cch=${cch}`);
+}
+function hasCchPlaceholder(body) {
+  return body.includes(CCH_PLACEHOLDER);
+}
+
+// src/index.ts
+import Anthropic from "@anthropic-ai/sdk";
+
+// src/model.ts
+import { APIError, RateLimitError } from "@anthropic-ai/sdk";
+
+// src/tool-names.ts
+import { existsSync as existsSync2, readFileSync as readFileSync3 } from "node:fs";
+import { homedir as homedir3 } from "node:os";
+import { join as join3 } from "node:path";
+var BUILTIN_OPENCODE_TO_CLAUDE = {
+  task: "Agent",
+  question: "AskUserQuestion",
+  plan_exit: "ExitPlanMode",
+  plan_enter: "EnterPlanMode",
+  bash: "Bash",
+  glob: "Glob",
+  grep: "Grep",
+  read: "Read",
+  edit: "Edit",
+  write: "Write",
+  webfetch: "WebFetch",
+  websearch: "WebSearch",
+  todowrite: "TodoWrite",
+  todoread: "TodoRead",
+  skill: "Skill",
+  multiedit: "MultiEdit",
+  list: "List",
+  apply_patch: "ApplyPatch",
+  batch: "Batch",
+  codesearch: "CodeSearch",
+  lsp: "LSP"
+};
+var BUILTIN_CLAUDE_TO_OPENCODE = {};
+for (const [oc, cc] of Object.entries(BUILTIN_OPENCODE_TO_CLAUDE)) {
+  BUILTIN_CLAUDE_TO_OPENCODE[cc] = oc;
+}
+var mcpServerNames = null;
+function detectMcpServers() {
+  const servers = new Set;
+  const paths = [
+    join3(process.cwd(), ".opencode", "opencode.json"),
+    join3(homedir3(), ".config", "opencode", "opencode.json"),
+    join3(homedir3(), ".config", "opencode", "opencode.jsonc")
+  ];
+  for (const p of paths) {
+    try {
+      if (!existsSync2(p))
+        continue;
+      let raw = readFileSync3(p, "utf-8");
+      raw = raw.replace(/\/\/.*$/gm, "").replace(/\/\*[\s\S]*?\*\//g, "");
+      const config = JSON.parse(raw);
+      if (config.mcp && typeof config.mcp === "object") {
+        for (const name of Object.keys(config.mcp)) {
+          servers.add(name.replace(/[^a-zA-Z0-9_-]/g, "_"));
+        }
+      }
+    } catch {}
+  }
+  return [...servers].toSorted((a, b) => b.length - a.length);
+}
+function getMcpServers() {
+  if (mcpServerNames === null) {
+    mcpServerNames = detectMcpServers();
+  }
+  return mcpServerNames;
+}
+function splitMcpToolName(name) {
+  const servers = getMcpServers();
+  for (const server of servers) {
+    if (name.startsWith(server + "_")) {
+      return { server, tool: name.slice(server.length + 1) };
+    }
+  }
+  const idx = name.indexOf("_");
+  if (idx > 0) {
+    return { server: name.slice(0, idx), tool: name.slice(idx + 1) };
+  }
+  return null;
+}
+function toClaudeToolName(opencodeName) {
+  const builtin = BUILTIN_OPENCODE_TO_CLAUDE[opencodeName];
+  if (builtin)
+    return builtin;
+  const parts = splitMcpToolName(opencodeName);
+  if (parts) {
+    return `mcp__${parts.server}__${parts.tool}`;
+  }
+  return opencodeName;
+}
+function toOpencodeToolName(claudeName) {
+  const builtin = BUILTIN_CLAUDE_TO_OPENCODE[claudeName];
+  if (builtin)
+    return builtin;
+  if (claudeName.startsWith("mcp__")) {
+    const rest = claudeName.slice(5);
+    const idx = rest.indexOf("__");
+    if (idx > 0) {
+      const server = rest.slice(0, idx);
+      const tool = rest.slice(idx + 2);
+      return `${server}_${tool}`;
+    }
+  }
+  return claudeName;
+}
+var SYSTEM_PROMPT_REPLACEMENTS = [
+  [
+    /^You are OpenCode, the best coding agent on the planet\.\s*\n\s*You are an interactive CLI tool that helps users with software engineering tasks\./m,
+    "You are an interactive agent that helps users with software engineering tasks."
+  ],
+  [/\bTask\s+tool/g, "Agent tool"],
+  [/\btask\s+tool/g, "Agent tool"],
+  [/\bthe\s+Task\b/g, "the Agent"],
+  [/\buse\s+(?:the\s+)?Task\b/g, "use the Agent"],
+  [/\bquestion\s+tool/g, "AskUserQuestion tool"],
+  [/\bthe\s+question\b(?=\s+to\s+ask)/g, "the AskUserQuestion"],
+  [/\buse\s+(?:the\s+)?bash\b/gi, "use the Bash"],
+  [/\buse\s+(?:the\s+)?read\b/gi, "use the Read"],
+  [/\buse\s+(?:the\s+)?write\b/gi, "use the Write"],
+  [/\buse\s+(?:the\s+)?edit\b/gi, "use the Edit"],
+  [/\buse\s+(?:the\s+)?glob\b/gi, "use the Glob"],
+  [/\buse\s+(?:the\s+)?grep\b/gi, "use the Grep"],
+  [/\buse\s+(?:the\s+)?skill\b/gi, "use the Skill"],
+  [/\buse\s+(?:the\s+)?webfetch\b/gi, "use the WebFetch"],
+  [/\buse\s+(?:the\s+)?websearch\b/gi, "use the WebSearch"],
+  [/\buse\s+(?:the\s+)?todowrite\b/gi, "use the TodoWrite"]
+];
+function rewriteToolNamesInText(text) {
+  let result = text;
+  for (const [pattern, replacement] of SYSTEM_PROMPT_REPLACEMENTS) {
+    result = result.replace(pattern, replacement);
+  }
+  return result;
+}
+
+// src/tools.ts
+function cleanSchema(schema) {
+  const cleaned = {};
+  for (const [key, value] of Object.entries(schema)) {
+    if (key === "custom")
+      continue;
+    if (value && typeof value === "object" && !Array.isArray(value)) {
+      cleaned[key] = cleanSchema(value);
+    } else {
+      cleaned[key] = value;
+    }
+  }
+  if (cleaned.properties && !cleaned.type) {
+    cleaned.type = "object";
+  }
+  return cleaned;
+}
+function convertTools(tools) {
+  if (!tools || tools.length === 0)
+    return;
+  return tools.filter((t) => t.type === "function").map((tool) => ({
+    name: toClaudeToolName(tool.name),
+    description: tool.description ?? "",
+    input_schema: cleanSchema(tool.inputSchema)
+  }));
+}
+function convertToolChoice(toolChoice) {
+  if (!toolChoice)
+    return;
+  switch (toolChoice.type) {
+    case "auto":
+      return { type: "auto" };
+    case "required":
+      return { type: "any" };
+    case "none":
+      return;
+    case "tool":
+      return { type: "tool", name: toClaudeToolName(toolChoice.toolName) };
+  }
+}
+
+// src/model.ts
+import { createHash, randomBytes } from "node:crypto";
+
+// src/prompt.ts
+function convertPrompt(prompt) {
+  const systemParts = [];
+  const messages = [];
+  for (const message of prompt) {
+    switch (message.role) {
+      case "system":
+        systemParts.push(message.content);
+        break;
+      case "user":
+        messages.push(convertUserMessage(message));
+        break;
+      case "assistant": {
+        const converted = convertAssistantMessage(message);
+        const content = converted.content;
+        if (Array.isArray(content) && content.length === 0)
+          break;
+        messages.push(converted);
+        break;
+      }
+      case "tool":
+        messages.push(convertToolMessage(message));
+        break;
+    }
+  }
+  return {
+    system: systemParts.length > 0 ? systemParts.join(`
+
+`) : undefined,
+    messages
+  };
+}
+function convertUserMessage(message) {
+  const content = [];
+  for (const part of message.content) {
+    switch (part.type) {
+      case "text":
+        content.push({ type: "text", text: part.text });
+        break;
+      case "file":
+        if (typeof part.data === "string" && part.mediaType?.startsWith("image/")) {
+          content.push({
+            type: "image",
+            source: {
+              type: "base64",
+              media_type: part.mediaType,
+              data: part.data
+            }
+          });
+        } else if (part.data instanceof URL) {
+          content.push({
+            type: "image",
+            source: {
+              type: "url",
+              url: part.data.toString()
+            }
+          });
+        }
+        break;
+    }
+  }
+  if (content.length === 1 && content[0].type === "text") {
+    return { role: "user", content: content[0].text };
+  }
+  return { role: "user", content };
+}
+function convertAssistantMessage(message) {
+  const content = [];
+  for (const part of message.content) {
+    switch (part.type) {
+      case "text":
+        if (part.text.length > 0) {
+          content.push({ type: "text", text: part.text });
+        }
+        break;
+      case "reasoning":
+        {
+          const signature = part.providerMetadata?.anthropic?.signature ?? part.providerOptions?.anthropic?.signature ?? "";
+          if (signature) {
+            content.push({
+              type: "thinking",
+              thinking: part.text,
+              signature
+            });
+          }
+          break;
+        }
+        break;
+      case "tool-call":
+        content.push({
+          type: "tool_use",
+          id: part.toolCallId,
+          name: toClaudeToolName(part.toolName),
+          input: typeof part.input === "string" ? JSON.parse(part.input) : part.input
+        });
+        break;
+      case "file":
+        break;
+      case "tool-result":
+        break;
+    }
+  }
+  return { role: "assistant", content };
+}
+function convertToolMessage(message) {
+  const content = [];
+  for (const part of message.content) {
+    if (part.type !== "tool-result")
+      continue;
+    const output = part.output;
+    const resultContent = formatToolResultContent(output);
+    content.push({
+      type: "tool_result",
+      tool_use_id: part.toolCallId,
+      content: resultContent,
+      is_error: output.type === "error-text" || output.type === "error-json" ? true : undefined
+    });
+  }
+  return { role: "user", content };
+}
+function formatToolResultContent(output) {
+  switch (output.type) {
+    case "text":
+    case "error-text":
+      return output.value;
+    case "json":
+    case "error-json":
+      return JSON.stringify(output.value);
+    case "content": {
+      const parts = [];
+      for (const item of output.value) {
+        if (item.type === "text") {
+          parts.push({ type: "text", text: item.text });
+        }
+      }
+      return parts.length === 1 ? parts[0].text : parts;
+    }
+    default:
+      return String(output.value);
+  }
+}
+
+// src/stream.ts
+var idCounter = 0;
+function generateId() {
+  return `block-${Date.now()}-${idCounter++}`;
+}
+function mapFinishReason(stopReason) {
+  const unified = (() => {
+    switch (stopReason) {
+      case "end_turn":
+      case "stop_sequence":
+        return "stop";
+      case "max_tokens":
+        return "length";
+      case "tool_use":
+        return "tool-calls";
+      default:
+        return "other";
+    }
+  })();
+  return { unified, raw: stopReason ?? undefined };
+}
+function convertStream(anthropicStream, modelId) {
+  const blockStates = new Map;
+  let inputTokens;
+  let outputTokens;
+  let cachedInputTokens;
+  let cacheCreationTokens;
+  return new ReadableStream({
+    async start(controller) {
+      try {
+        for await (const event of anthropicStream) {
+          const parts = processEvent(event, blockStates, modelId);
+          if (event.type === "message_start" && event.message.usage) {
+            const u = event.message.usage;
+            inputTokens = u.input_tokens;
+            cachedInputTokens = u.cache_read_input_tokens ?? 0;
+            cacheCreationTokens = u.cache_creation_input_tokens ?? 0;
+          }
+          if (event.type === "message_delta") {
+            const delta = event;
+            outputTokens = delta.usage?.output_tokens;
+            const finishReason = mapFinishReason(delta.delta?.stop_reason);
+            controller.enqueue({
+              type: "finish",
+              finishReason,
+              usage: {
+                inputTokens: {
+                  total: inputTokens ?? 0,
+                  noCache: undefined,
+                  cacheRead: cachedInputTokens ?? 0,
+                  cacheWrite: cacheCreationTokens ?? 0
+                },
+                outputTokens: {
+                  total: outputTokens ?? 0,
+                  text: undefined,
+                  reasoning: undefined
+                }
+              },
+              providerMetadata: {
+                anthropic: {
+                  cacheCreationInputTokens: cacheCreationTokens ?? 0
+                }
+              }
+            });
+          }
+          for (const part of parts) {
+            controller.enqueue(part);
+          }
+        }
+      } catch (error) {
+        controller.enqueue({ type: "error", error });
+      } finally {
+        controller.close();
+      }
+    }
+  });
+}
+function processEvent(event, blockStates, modelId) {
+  const parts = [];
+  switch (event.type) {
+    case "message_start": {
+      parts.push({
+        type: "response-metadata",
+        id: event.message.id,
+        modelId: event.message.model ?? modelId,
+        timestamp: new Date
+      });
+      break;
+    }
+    case "content_block_start": {
+      const index = event.index;
+      const block = event.content_block;
+      if (block.type === "text") {
+        const id = generateId();
+        blockStates.set(index, { type: "text", id });
+        parts.push({ type: "text-start", id });
+      } else if (block.type === "thinking") {
+        const id = generateId();
+        blockStates.set(index, { type: "thinking", id });
+        parts.push({ type: "reasoning-start", id });
+      } else if (block.type === "tool_use") {
+        const toolId = block.id;
+        const toolName = toOpencodeToolName(block.name);
+        blockStates.set(index, {
+          type: "tool_use",
+          id: toolId,
+          toolUseId: toolId,
+          toolName,
+          argsText: ""
+        });
+        parts.push({
+          type: "tool-input-start",
+          id: toolId,
+          toolName
+        });
+      }
+      break;
+    }
+    case "content_block_delta": {
+      const index = event.index;
+      const state = blockStates.get(index);
+      if (!state)
+        break;
+      const delta = event.delta;
+      if (delta.type === "text_delta" && state.type === "text") {
+        parts.push({
+          type: "text-delta",
+          id: state.id,
+          delta: delta.text
+        });
+      } else if (delta.type === "thinking_delta" && state.type === "thinking") {
+        parts.push({
+          type: "reasoning-delta",
+          id: state.id,
+          delta: delta.thinking
+        });
+      } else if (delta.type === "signature_delta" && state.type === "thinking") {
+        state.signature = (state.signature ?? "") + delta.signature;
+      } else if (delta.type === "input_json_delta" && state.type === "tool_use") {
+        state.argsText = (state.argsText ?? "") + delta.partial_json;
+        parts.push({
+          type: "tool-input-delta",
+          id: state.id,
+          delta: delta.partial_json
+        });
+      }
+      break;
+    }
+    case "content_block_stop": {
+      const index = event.index;
+      const state = blockStates.get(index);
+      if (!state)
+        break;
+      if (state.type === "text") {
+        parts.push({ type: "text-end", id: state.id });
+      } else if (state.type === "thinking") {
+        parts.push({
+          type: "reasoning-end",
+          id: state.id,
+          ...state.signature ? {
+            providerMetadata: { anthropic: { signature: state.signature } }
+          } : {}
+        });
+      } else if (state.type === "tool_use") {
+        parts.push({ type: "tool-input-end", id: state.id });
+        parts.push({
+          type: "tool-call",
+          toolCallId: state.toolUseId,
+          toolName: state.toolName,
+          input: state.argsText || "{}"
+        });
+      }
+      blockStates.delete(index);
+      break;
+    }
+  }
+  return parts;
+}
+
+// src/model.ts
+function handleApiError(error) {
+  if (error instanceof RateLimitError || error instanceof APIError && error.status === 429) {
+    const h = error.headers;
+    const getHeader = (name) => h?.get?.(name) ?? h?.[name] ?? null;
+    const errorMsg = error.error?.error?.message ?? error.message ?? "";
+    if (errorMsg.includes("Extra usage is required for long context")) {
+      throw new Error(`Long context request requires "Extra usage" to be enabled in your Claude subscription. ` + `Go to claude.ai/settings and enable Extra usage, or reduce context size.`);
+    }
+    const unifiedStatus = getHeader("anthropic-ratelimit-unified-status") ?? "";
+    const retryAfter = parseInt(getHeader("retry-after") ?? "0");
+    const isSubscriptionLimit = unifiedStatus === "over_limit" || retryAfter > 120;
+    if (isSubscriptionLimit) {
+      const resetInfo = retryAfter > 0 ? ` Resets in ~${Math.ceil(retryAfter / 60)} minutes.` : "";
+      throw new Error(`Claude subscription rate limit reached.${resetInfo} ` + `Use /rate-limit-options in Claude Code to check your options, ` + `or wait for your limit to reset.`);
+    }
+    throw new Error(`Anthropic API rate limit exceeded after retries. ` + (retryAfter > 0 ? `Retry after ${retryAfter}s.` : `Please try again shortly.`));
+  }
+  throw error;
+}
+function mapFinishReason2(stopReason) {
+  const unified = (() => {
+    switch (stopReason) {
+      case "end_turn":
+      case "stop_sequence":
+        return "stop";
+      case "max_tokens":
+        return "length";
+      case "tool_use":
+        return "tool-calls";
+      default:
+        return "other";
+    }
+  })();
+  return { unified, raw: stopReason ?? undefined };
+}
+var BILLING_SYSTEM_BLOCK = {
+  type: "text",
+  text: "x-anthropic-billing-header: cc_version=2.1.81.df2; cc_entrypoint=sdk-cli; cch=00000;"
+};
+var IDENTITY_SYSTEM_BLOCK = {
+  type: "text",
+  text: "You are a Claude agent, built on Anthropic's Claude Agent SDK."
+};
+var DEVICE_ID = createHash("sha256").update(randomBytes(32)).digest("hex");
+function buildMetadata() {
+  return {
+    user_id: JSON.stringify({ device_id: DEVICE_ID })
+  };
+}
+
+class AnthropicSDKModel {
+  client;
+  providerName;
+  isOAuth;
+  specificationVersion = "v3";
+  provider;
+  modelId;
+  supportedUrls = {};
+  constructor(modelId, client, providerName, isOAuth = false) {
+    this.client = client;
+    this.providerName = providerName;
+    this.isOAuth = isOAuth;
+    this.modelId = modelId;
+    this.provider = providerName;
+  }
+  buildParams(options) {
+    const { system, messages } = convertPrompt(options.prompt);
+    const warnings = [];
+    if (options.presencePenalty != null) {
+      warnings.push({ type: "compatibility", feature: "presencePenalty" });
+    }
+    if (options.frequencyPenalty != null) {
+      warnings.push({ type: "compatibility", feature: "frequencyPenalty" });
+    }
+    if (options.seed != null) {
+      warnings.push({ type: "compatibility", feature: "seed" });
+    }
+    const tools = options.toolChoice?.type === "none" ? undefined : convertTools(options.tools);
+    const toolChoice = options.toolChoice?.type === "none" ? undefined : convertToolChoice(options.toolChoice);
+    const params = {
+      model: this.modelId,
+      max_tokens: options.maxOutputTokens ?? 64000,
+      messages
+    };
+    if (this.isOAuth) {
+      const rewrite = (s) => rewriteToolNamesInText(s);
+      const SYSTEM_CACHE = { type: "ephemeral", ttl: "1h", scope: "global" };
+      if (system) {
+        const contentBlocks = typeof system === "string" ? [{ type: "text", text: rewrite(system), cache_control: SYSTEM_CACHE }] : Array.isArray(system) ? system.map((b, i) => b.type === "text" ? {
+          ...b,
+          text: rewrite(b.text),
+          ...i === system.length - 1 ? { cache_control: SYSTEM_CACHE } : {}
+        } : b) : [{ ...system, cache_control: SYSTEM_CACHE }];
+        params.system = [BILLING_SYSTEM_BLOCK, IDENTITY_SYSTEM_BLOCK, ...contentBlocks];
+      } else {
+        params.system = [BILLING_SYSTEM_BLOCK, IDENTITY_SYSTEM_BLOCK];
+      }
+      params.metadata = buildMetadata();
+      const supportsEffort = !this.modelId.includes("haiku") && !this.modelId.includes("claude-3-");
+      if (supportsEffort) {
+        if (options.temperature == null) {
+          params.temperature = 1;
+        }
+        const providerOpts = options.providerOptions?.["anthropic-sdk"] ?? options.providerOptions?.anthropic;
+        const effort = providerOpts?.effort ?? "medium";
+        params.output_config = { effort };
+      }
+    } else if (system) {
+      const CACHE = { type: "ephemeral" };
+      if (typeof system === "string") {
+        params.system = [
+          { ...IDENTITY_SYSTEM_BLOCK, cache_control: CACHE },
+          { type: "text", text: system, cache_control: CACHE }
+        ];
+      } else if (Array.isArray(system)) {
+        const blocks = system.map((b, i) => b.type === "text" && i === system.length - 1 ? { ...b, cache_control: CACHE } : b);
+        params.system = [{ ...IDENTITY_SYSTEM_BLOCK, cache_control: CACHE }, ...blocks];
+      } else {
+        params.system = [
+          { ...IDENTITY_SYSTEM_BLOCK, cache_control: CACHE },
+          { ...system, cache_control: CACHE }
+        ];
+      }
+    }
+    if (tools && tools.length > 0)
+      params.tools = tools;
+    if (toolChoice)
+      params.tool_choice = toolChoice;
+    if (params.messages && params.messages.length > 1) {
+      const msgs = params.messages;
+      const msgCache = this.isOAuth ? { type: "ephemeral", ttl: "1h" } : { type: "ephemeral" };
+      let cachedSomething = false;
+      for (let i = msgs.length - 1;i >= 0; i--) {
+        const msg = msgs[i];
+        if (msg.role !== "user" || !Array.isArray(msg.content))
+          continue;
+        for (let j = msg.content.length - 1;j >= 0; j--) {
+          const block = msg.content[j];
+          if (block.type === "tool_result" && !block.cache_control) {
+            block.cache_control = msgCache;
+            cachedSomething = true;
+            break;
+          }
+        }
+        if (cachedSomething)
+          break;
+      }
+      if (!cachedSomething) {
+        const msg = msgs[msgs.length - 2];
+        if (msg && Array.isArray(msg.content) && msg.content.length > 0) {
+          const lastContent = msg.content[msg.content.length - 1];
+          if (lastContent && !lastContent.cache_control) {
+            lastContent.cache_control = msgCache;
+          }
+        } else if (msg && typeof msg.content === "string") {
+          msgs[msgs.length - 2] = {
+            ...msg,
+            content: [{ type: "text", text: msg.content, cache_control: msgCache }]
+          };
+        }
+      }
+    }
+    if (options.temperature != null)
+      params.temperature = options.temperature;
+    if (options.topP != null)
+      params.top_p = options.topP;
+    if (options.topK != null)
+      params.top_k = options.topK;
+    if (options.stopSequences && options.stopSequences.length > 0) {
+      params.stop_sequences = options.stopSequences;
+    }
+    const anthropicOptions = options.providerOptions?.["anthropic-sdk"] ?? options.providerOptions?.anthropic;
+    if (anthropicOptions) {
+      if (anthropicOptions.thinking) {
+        const t = anthropicOptions.thinking;
+        if (t.type === "enabled" && t.budgetTokens) {
+          params.thinking = { type: "enabled", budget_tokens: t.budgetTokens };
+        } else if (t.type === "adaptive") {
+          params.thinking = { type: "enabled", budget_tokens: 1e4 };
+        } else {
+          params.thinking = t;
+        }
+      }
+      if (anthropicOptions.metadata)
+        params.metadata = anthropicOptions.metadata;
+    }
+    return { params, warnings };
+  }
+  async doGenerate(options) {
+    const { params, warnings } = this.buildParams(options);
+    if (!options.maxOutputTokens && params.max_tokens > 4096) {
+      params.max_tokens = 4096;
+    }
+    let response;
+    try {
+      response = await this.client.messages.create({
+        ...params,
+        stream: false
+      }, { signal: options.abortSignal });
+    } catch (error) {
+      handleApiError(error);
+    }
+    const content = [];
+    for (const block of response.content) {
+      switch (block.type) {
+        case "text":
+          content.push({ type: "text", text: block.text });
+          break;
+        case "tool_use":
+          content.push({
+            type: "tool-call",
+            toolCallId: block.id,
+            toolName: toOpencodeToolName(block.name),
+            input: JSON.stringify(block.input)
+          });
+          break;
+        default: {
+          const anyBlock = block;
+          if (anyBlock.type === "thinking" && anyBlock.thinking) {
+            content.push({
+              type: "reasoning",
+              text: anyBlock.thinking,
+              providerMetadata: anyBlock.signature ? { anthropic: { signature: anyBlock.signature } } : undefined
+            });
+          }
+          break;
+        }
+      }
+    }
+    const cacheReadTokens = response.usage.cache_read_input_tokens ?? 0;
+    const cacheCreateTokens = response.usage.cache_creation_input_tokens ?? 0;
+    return {
+      content,
+      finishReason: mapFinishReason2(response.stop_reason),
+      usage: {
+        inputTokens: {
+          total: response.usage.input_tokens,
+          noCache: undefined,
+          cacheRead: cacheReadTokens,
+          cacheWrite: cacheCreateTokens
+        },
+        outputTokens: {
+          total: response.usage.output_tokens,
+          text: undefined,
+          reasoning: undefined
+        }
+      },
+      providerMetadata: {
+        anthropic: {
+          cacheCreationInputTokens: cacheCreateTokens
+        }
+      },
+      response: {
+        id: response.id,
+        modelId: response.model,
+        timestamp: new Date
+      },
+      warnings
+    };
+  }
+  async doStream(options) {
+    const { params, warnings } = this.buildParams(options);
+    let anthropicStream;
+    try {
+      anthropicStream = await this.client.messages.create({
+        ...params,
+        stream: true
+      }, { signal: options.abortSignal });
+    } catch (error) {
+      if (error instanceof APIError && error.status === 400 && error.message?.includes("must end with a user message")) {
+        return {
+          stream: new ReadableStream({
+            start(controller) {
+              controller.enqueue({ type: "stream-start", warnings });
+              controller.enqueue({
+                type: "finish",
+                finishReason: { unified: "stop", raw: undefined },
+                usage: {
+                  inputTokens: {
+                    total: 0,
+                    noCache: undefined,
+                    cacheRead: undefined,
+                    cacheWrite: undefined
+                  },
+                  outputTokens: { total: 0, text: undefined, reasoning: undefined }
+                }
+              });
+              controller.close();
+            }
+          }),
+          request: { body: params }
+        };
+      }
+      handleApiError(error);
+    }
+    const stream = convertStream(anthropicStream, this.modelId);
+    const wrappedStream = new ReadableStream({
+      async start(controller) {
+        controller.enqueue({
+          type: "stream-start",
+          warnings
+        });
+        const reader = stream.getReader();
+        try {
+          while (true) {
+            const { done, value } = await reader.read();
+            if (done)
+              break;
+            controller.enqueue(value);
+          }
+        } finally {
+          reader.releaseLock();
+          controller.close();
+        }
+      }
+    });
+    return {
+      stream: wrappedStream,
+      request: { body: params }
+    };
+  }
+}
+
+// src/index.ts
+var CLAUDE_CODE_VERSION = "2.1.81";
+var OAUTH_BETAS = [
+  "claude-code-20250219",
+  "oauth-2025-04-20",
+  "interleaved-thinking-2025-05-14",
+  "context-management-2025-06-27",
+  "prompt-caching-scope-2026-01-05",
+  "effort-2025-11-24"
+];
+var CONTEXT_1M_BETA = "context-1m-2025-08-07";
+var API_KEY_BETAS = ["interleaved-thinking-2025-05-14", "fine-grained-tool-streaming-2025-05-14"];
+var PACKAGE_NAME = "@xtruder/opencode-claude-max-plugin";
+var PROVIDER_ID = "anthropic-sdk";
+var PLUGIN_MODELS = {
+  "claude-haiku-4-5": {
+    name: "Claude Haiku 4.5",
+    reasoning: false,
+    tool_call: true,
+    attachment: true,
+    temperature: true,
+    limit: { context: 200000, output: 8192 },
+    cost: { input: 0.8, output: 4, cache_read: 0.08, cache_write: 1 },
+    modalities: {
+      input: ["text", "image"],
+      output: ["text"]
+    }
+  },
+  "claude-sonnet-4-6": {
+    name: "Claude Sonnet 4.6",
+    reasoning: true,
+    tool_call: true,
+    attachment: true,
+    temperature: true,
+    limit: { context: 200000, output: 16000 },
+    cost: { input: 3, output: 15, cache_read: 0.3, cache_write: 3.75 },
+    modalities: {
+      input: ["text", "image", "pdf"],
+      output: ["text"]
+    },
+    options: { effort: "medium" },
+    variants: {
+      low: { effort: "low" },
+      medium: { effort: "medium" },
+      high: { effort: "high" }
+    }
+  },
+  "claude-opus-4-6": {
+    name: "Claude Opus 4.6",
+    reasoning: true,
+    tool_call: true,
+    attachment: true,
+    temperature: true,
+    limit: { context: 200000, output: 32000 },
+    cost: { input: 15, output: 75, cache_read: 1.5, cache_write: 18.75 },
+    modalities: {
+      input: ["text", "image", "pdf"],
+      output: ["text"]
+    },
+    options: { effort: "medium" },
+    variants: {
+      low: { effort: "low" },
+      medium: { effort: "medium" },
+      high: { effort: "high" }
+    }
+  }
+};
+function resolveAuth(options) {
+  if (options.apiKey) {
+    return { apiKey: options.apiKey, isOAuth: false };
+  }
+  if (process.env.ANTHROPIC_API_KEY) {
+    return { apiKey: process.env.ANTHROPIC_API_KEY, isOAuth: false };
+  }
+  const credentialsPath = typeof options.credentialsPath === "string" ? options.credentialsPath : undefined;
+  const creds = getCachedCredentials(credentialsPath);
+  if (creds) {
+    return { apiKey: null, authToken: creds.accessToken, isOAuth: true };
+  }
+  return { isOAuth: false };
+}
+function createAnthropicSDK(options = {}) {
+  const { baseURL, headers, fetch: customFetch, name = "anthropic-sdk" } = options;
+  const credentialsPath = typeof options.credentialsPath === "string" ? options.credentialsPath : undefined;
+  const auth = resolveAuth(options);
+  const defaultHeaders = {
+    ...headers,
+    "anthropic-beta": (auth.isOAuth ? OAUTH_BETAS : API_KEY_BETAS).join(",")
+  };
+  if (auth.isOAuth) {
+    defaultHeaders["user-agent"] = `claude-cli/${CLAUDE_CODE_VERSION} (external, sdk-cli)`;
+    defaultHeaders["x-app"] = "cli";
+    defaultHeaders["anthropic-dangerous-direct-browser-access"] = "true";
+    defaultHeaders["x-stainless-package-version"] = "0.74.0";
+  }
+  const CONTEXT_1M_BODY_THRESHOLD = 600000;
+  const baseFetch = customFetch ?? globalThis.fetch;
+  const wrappedFetch = async (url, init) => {
+    if (auth.isOAuth && init) {
+      const freshCreds = getCachedCredentials(credentialsPath);
+      if (freshCreds) {
+        const reqHeaders = new Headers(init.headers);
+        reqHeaders.set("authorization", `Bearer ${freshCreds.accessToken}`);
+        init = { ...init, headers: reqHeaders };
+      }
+    }
+    if (init?.body && typeof init.body === "string" && init.body.length > CONTEXT_1M_BODY_THRESHOLD) {
+      const betaHeaders = new Headers(init.headers);
+      const existingBetas = betaHeaders.get("anthropic-beta") ?? "";
+      if (!existingBetas.includes(CONTEXT_1M_BETA)) {
+        betaHeaders.set("anthropic-beta", existingBetas + "," + CONTEXT_1M_BETA);
+        init = { ...init, headers: betaHeaders };
+      }
+    }
+    if (auth.isOAuth && init?.body && typeof init.body === "string" && hasCchPlaceholder(init.body)) {
+      try {
+        const cch = await computeCch(init.body);
+        init = { ...init, body: replaceCchPlaceholder(init.body, cch) };
+      } catch {}
+    }
+    const resp = await baseFetch(url, init);
+    const h5 = resp.headers.get("anthropic-ratelimit-unified-5h-utilization");
+    if (h5 != null) {
+      cachedUsage.fiveHourUtil = parseFloat(h5);
+      cachedUsage.sevenDayUtil = parseFloat(resp.headers.get("anthropic-ratelimit-unified-7d-utilization") ?? "0");
+      cachedUsage.fiveHourReset = parseInt(resp.headers.get("anthropic-ratelimit-unified-5h-reset") ?? "0");
+      cachedUsage.sevenDayReset = parseInt(resp.headers.get("anthropic-ratelimit-unified-7d-reset") ?? "0");
+      cachedUsage.overageStatus = resp.headers.get("anthropic-ratelimit-unified-overage-status") ?? undefined;
+      persistCachedUsage();
+    }
+    if (resp.status === 429) {
+      const unifiedStatus = resp.headers.get("anthropic-ratelimit-unified-status") ?? "";
+      const retryAfter = parseInt(resp.headers.get("retry-after") ?? "0");
+      const bodyText = await resp.clone().text();
+      const isLongContextLimit = bodyText.includes("Extra usage is required for long context");
+      const isSubscriptionLimit = isLongContextLimit || unifiedStatus === "over_limit" || retryAfter > 120;
+      if (isSubscriptionLimit) {
+        const retryHeaders = new Headers(resp.headers);
+        retryHeaders.set("x-should-retry", "false");
+        return new Response(bodyText, {
+          status: resp.status,
+          statusText: resp.statusText,
+          headers: retryHeaders
+        });
+      }
+    }
+    return resp;
+  };
+  const client = new Anthropic({
+    apiKey: auth.apiKey ?? null,
+    authToken: auth.authToken ?? null,
+    baseURL,
+    defaultHeaders,
+    fetch: wrappedFetch
+  });
+  return {
+    languageModel(modelId) {
+      return new AnthropicSDKModel(modelId, client, name, auth.isOAuth);
+    }
+  };
+}
+var anthropicSDKPlugin = async () => {
+  return {
+    config: async (cfg) => {
+      if (!cfg.provider) {
+        cfg.provider = {};
+      }
+      cfg.provider[PROVIDER_ID] = {
+        npm: PACKAGE_NAME,
+        models: PLUGIN_MODELS,
+        ...cfg.provider[PROVIDER_ID]
+      };
+    }
+  };
+};
+var src_default = createAnthropicSDK;
+
+// src/server.ts
+var id = "anthropic-sdk";
+var server = anthropicSDKPlugin;
+var plugin = {
+  id,
+  server
+};
+var server_default = plugin;
+export {
+  server_default as default
+};