@xtruder/opencode-claude-max-plugin 0.1.0

package/build/index.js

@@ -0,0 +1,881 @@
+// src/index.ts
+import Anthropic from "@anthropic-ai/sdk";
+
+// src/tool-names.ts
+import { readFileSync, existsSync } from "node:fs";
+import { join } from "node:path";
+import { homedir } from "node:os";
+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_OPENCODE_NAMES = new Set(Object.keys(BUILTIN_OPENCODE_TO_CLAUDE));
+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 = [
+    join(process.cwd(), ".opencode", "opencode.json"),
+    join(homedir(), ".config", "opencode", "opencode.json"),
+    join(homedir(), ".config", "opencode", "opencode.jsonc")
+  ];
+  for (const p of paths) {
+    try {
+      if (!existsSync(p))
+        continue;
+      let raw = readFileSync(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].sort((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/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":
+        messages.push(convertAssistantMessage(message));
+        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) {
+    const resultContent = formatToolResultContent(part.output);
+    content.push({
+      type: "tool_result",
+      tool_use_id: part.toolCallId,
+      content: resultContent,
+      is_error: part.output.type === "error-text" || part.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/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/stream.ts
+var idCounter = 0;
+function generateId() {
+  return `block-${Date.now()}-${idCounter++}`;
+}
+function mapFinishReason(stopReason) {
+  switch (stopReason) {
+    case "end_turn":
+      return "stop";
+    case "stop_sequence":
+      return "stop";
+    case "max_tokens":
+      return "length";
+    case "tool_use":
+      return "tool-calls";
+    default:
+      return "unknown";
+  }
+}
+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: inputTokens ?? 0,
+                outputTokens: outputTokens ?? 0,
+                totalTokens: (inputTokens ?? 0) + (outputTokens ?? 0),
+                cachedInputTokens
+              }
+            });
+          }
+          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
+import { randomBytes, createHash } from "node:crypto";
+import { APIError, RateLimitError } from "@anthropic-ai/sdk";
+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) {
+  switch (stopReason) {
+    case "end_turn":
+      return "stop";
+    case "stop_sequence":
+      return "stop";
+    case "max_tokens":
+      return "length";
+    case "tool_use":
+      return "tool-calls";
+    default:
+      return "unknown";
+  }
+}
+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 = "v2";
+  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: "unsupported-setting", setting: "presencePenalty" });
+    }
+    if (options.frequencyPenalty != null) {
+      warnings.push({ type: "unsupported-setting", setting: "frequencyPenalty" });
+    }
+    if (options.seed != null) {
+      warnings.push({ type: "unsupported-setting", setting: "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;
+        }
+        params.output_config = { effort: "medium" };
+      }
+    } 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);
+    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;
+        }
+      }
+    }
+    return {
+      content,
+      finishReason: mapFinishReason2(response.stop_reason),
+      usage: {
+        inputTokens: response.usage.input_tokens,
+        outputTokens: response.usage.output_tokens,
+        totalTokens: response.usage.input_tokens + response.usage.output_tokens,
+        cachedInputTokens: response.usage.cache_read_input_tokens
+      },
+      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) {
+      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/credentials.ts
+import { readFileSync as readFileSync2, existsSync as existsSync2 } from "node:fs";
+import { join as join2 } from "node:path";
+import { homedir as homedir2 } from "node:os";
+function getCredentialsPath() {
+  return join2(homedir2(), ".claude", ".credentials.json");
+}
+function readClaudeCredentials(path) {
+  const credPath = path ?? getCredentialsPath();
+  if (!existsSync2(credPath))
+    return null;
+  try {
+    const raw = readFileSync2(credPath, "utf-8");
+    const parsed = JSON.parse(raw);
+    if (!parsed.claudeAiOauth?.accessToken)
+      return null;
+    return parsed.claudeAiOauth;
+  } catch {
+    return null;
+  }
+}
+function isExpired(creds) {
+  const buffer = 5 * 60 * 1000;
+  return Date.now() > creds.expiresAt - buffer;
+}
+
+// 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"
+];
+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 creds = readClaudeCredentials(options.credentialsPath);
+  if (creds) {
+    if (isExpired(creds)) {
+      console.warn("[anthropic-sdk-provider] Claude Code OAuth token is expired. " + "Run 'claude' to re-authenticate, then restart.");
+    }
+    return { apiKey: null, authToken: creds.accessToken, isOAuth: true };
+  }
+  return { isOAuth: false };
+}
+function createAnthropicSDK(options = {}) {
+  const {
+    apiKey,
+    baseURL,
+    headers,
+    fetch: customFetch,
+    name = "anthropic-sdk",
+    credentialsPath,
+    ...rest
+  } = options;
+  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 (init?.body && typeof init.body === "string" && init.body.length > CONTEXT_1M_BODY_THRESHOLD) {
+      const headers2 = new Headers(init.headers);
+      const existingBetas = headers2.get("anthropic-beta") ?? "";
+      if (!existingBetas.includes(CONTEXT_1M_BETA)) {
+        headers2.set("anthropic-beta", existingBetas + "," + CONTEXT_1M_BETA);
+        init = { ...init, headers: headers2 };
+      }
+    }
+    const resp = await baseFetch(url, init);
+    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 body = bodyText;
+        const headers2 = new Headers(resp.headers);
+        headers2.set("x-should-retry", "false");
+        return new Response(body, {
+          status: resp.status,
+          statusText: resp.statusText,
+          headers: headers2
+        });
+      }
+    }
+    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 src_default = createAnthropicSDK;
+export {
+  readClaudeCredentials,
+  isExpired,
+  getCredentialsPath,
+  src_default as default,
+  createAnthropicSDK,
+  OAUTH_BETAS,
+  CONTEXT_1M_BETA,
+  AnthropicSDKModel,
+  API_KEY_BETAS
+};