pi-anthropic-oauth 0.1.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Leo Henon
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,35 @@
+# Pi Anthropic OAuth
+
+[![npm](https://img.shields.io/npm/v/pi-anthropic-oauth?style=flat-square&logo=npm&logoColor=white&label=npm&color=7c3aed)](https://www.npmjs.com/package/pi-anthropic-oauth) [![node](https://img.shields.io/badge/node-%3E%3D18-7c3aed?style=flat-square&logo=nodedotjs&logoColor=white)](https://nodejs.org)
+
+Claude Pro/Max OAuth extension for Pi.
+
+> [!WARNING]
+> Use this at your own risk. This may go against Anthropic's terms.
+
+## Install
+
+```bash
+pi install npm:pi-anthropic-oauth
+```
+
+Start Pi, then run:
+
+```text
+/login anthropic
+```
+
+Choose:
+
+```text
+Claude Pro/Max
+```
+
+## Notes
+
+- sends Claude Code-like OAuth headers
+- rewrites Pi system identity where needed
+
+## License
+
+MIT

package/package.json

@@ -0,0 +1,56 @@
+{
+  "name": "pi-anthropic-oauth",
+  "version": "0.1.0",
+  "description": "Claude Pro/Max OAuth extension for Pi",
+  "type": "module",
+  "license": "MIT",
+  "keywords": [
+    "pi-package",
+    "pi",
+    "anthropic",
+    "claude",
+    "oauth",
+    "extension"
+  ],
+  "files": [
+    "src",
+    "README.md",
+    "LICENSE"
+  ],
+  "engines": {
+    "node": ">=18"
+  },
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/leohenon/pi-anthropic-oauth"
+  },
+  "bugs": {
+    "url": "https://github.com/leohenon/pi-anthropic-oauth/issues"
+  },
+  "homepage": "https://github.com/leohenon/pi-anthropic-oauth#readme",
+  "publishConfig": {
+    "access": "public"
+  },
+  "scripts": {
+    "check": "tsc -p tsconfig.json --noEmit",
+    "pack:check": "npm pack --dry-run",
+    "prepublishOnly": "npm run check && npm run pack:check"
+  },
+  "pi": {
+    "extensions": [
+      "./src/index.ts"
+    ]
+  },
+  "dependencies": {
+    "@anthropic-ai/sdk": "^0.52.0"
+  },
+  "peerDependencies": {
+    "@mariozechner/pi-ai": "*",
+    "@mariozechner/pi-coding-agent": "*"
+  },
+  "devDependencies": {
+    "@mariozechner/pi-ai": "^0.66.1",
+    "@mariozechner/pi-coding-agent": "^0.66.1",
+    "typescript": "^5.9.3"
+  }
+}

package/src/auth.ts

@@ -0,0 +1,295 @@
+import { createServer } from "node:http";
+import type {
+  OAuthCredentials,
+  OAuthLoginCallbacks,
+} from "@mariozechner/pi-ai";
+
+const CLIENT_ID = "9d1c250a-e61b-44d9-88ed-5944d1962f5e";
+const AUTHORIZE_URL = "https://claude.ai/oauth/authorize";
+const TOKEN_URL = "https://platform.claude.com/v1/oauth/token";
+const REDIRECT_URI = "https://platform.claude.com/oauth/code/callback";
+const SCOPES = [
+  "org:create_api_key",
+  "user:profile",
+  "user:inference",
+  "user:sessions:claude_code",
+  "user:mcp_servers",
+  "user:file_upload",
+].join(" ");
+const USER_AGENT = "claude-code/2.1.96";
+const LOCAL_CALLBACK_TIMEOUT = 5 * 60 * 1000;
+
+export { USER_AGENT };
+
+type ParsedAuthInput = { code: string; state: string };
+type LocalAuthorization = {
+  redirectUri: string;
+  waitForCallback: () => Promise<string | null>;
+};
+
+export function isClaudeOAuthAccessToken(apiKey: string): boolean {
+  return apiKey.includes("sk-ant-oat");
+}
+
+export async function loginAnthropic(
+  callbacks: OAuthLoginCallbacks,
+): Promise<OAuthCredentials> {
+  const { verifier, challenge } = await generatePKCE();
+  const state = crypto.randomUUID().replace(/-/g, "");
+
+  let authInput: string | null = null;
+  let redirectUri = REDIRECT_URI;
+
+  try {
+    const localAuthorization = await createLocalAuthorization(state);
+    redirectUri = localAuthorization.redirectUri;
+
+    callbacks.onAuth({
+      url: makeAuthorizeUrl(challenge, state, redirectUri),
+      instructions:
+        "Complete authorization in the browser. Pi will try to capture the callback automatically.",
+    });
+
+    authInput = await localAuthorization.waitForCallback();
+  } catch {
+    // Fall back to manual code entry when localhost callback setup fails.
+  }
+
+  if (!authInput) {
+    redirectUri = REDIRECT_URI;
+    callbacks.onAuth({
+      url: makeAuthorizeUrl(challenge, state, redirectUri),
+      instructions:
+        "Sign in with Claude, then paste the full callback URL or the code#state value.",
+    });
+    authInput = await callbacks.onPrompt({
+      message: "Paste the callback URL or code#state:",
+    });
+  }
+
+  const parsed = parseAuthInput(authInput);
+  if (!parsed) throw new Error("Could not parse authorization callback input.");
+  if (parsed.state !== state) throw new Error("OAuth state mismatch.");
+
+  const tokenResponse = await fetch(TOKEN_URL, {
+    method: "POST",
+    headers: makeTokenHeaders(),
+    body: new URLSearchParams({
+      grant_type: "authorization_code",
+      client_id: CLIENT_ID,
+      code: parsed.code,
+      state: parsed.state,
+      redirect_uri: redirectUri,
+      code_verifier: verifier,
+    }).toString(),
+    signal: callbacks.signal,
+  });
+
+  if (!tokenResponse.ok) {
+    throw new Error(
+      `Token exchange failed: ${tokenResponse.status} ${await tokenResponse.text()}`,
+    );
+  }
+
+  const data = (await tokenResponse.json()) as {
+    access_token: string;
+    refresh_token: string;
+    expires_in: number;
+  };
+
+  return {
+    access: data.access_token,
+    refresh: data.refresh_token,
+    expires: Date.now() + data.expires_in * 1000 - 5 * 60 * 1000,
+  };
+}
+
+export async function refreshAnthropicToken(
+  credentials: OAuthCredentials,
+): Promise<OAuthCredentials> {
+  const response = await fetch(TOKEN_URL, {
+    method: "POST",
+    headers: makeTokenHeaders(),
+    body: new URLSearchParams({
+      grant_type: "refresh_token",
+      client_id: CLIENT_ID,
+      refresh_token: credentials.refresh,
+    }).toString(),
+  });
+
+  if (!response.ok) {
+    throw new Error(
+      `Token refresh failed: ${response.status} ${await response.text()}`,
+    );
+  }
+
+  const data = (await response.json()) as {
+    access_token: string;
+    refresh_token: string;
+    expires_in: number;
+  };
+
+  return {
+    access: data.access_token,
+    refresh: data.refresh_token || credentials.refresh,
+    expires: Date.now() + data.expires_in * 1000 - 5 * 60 * 1000,
+  };
+}
+
+function makeAuthorizeUrl(
+  challenge: string,
+  state: string,
+  redirectUri: string,
+): string {
+  const authParams = new URLSearchParams({
+    code: "true",
+    client_id: CLIENT_ID,
+    response_type: "code",
+    redirect_uri: redirectUri,
+    scope: SCOPES,
+    code_challenge: challenge,
+    code_challenge_method: "S256",
+    state,
+  });
+
+  return `${AUTHORIZE_URL}?${authParams.toString()}`;
+}
+
+function makeTokenHeaders(): HeadersInit {
+  return {
+    Accept: "application/json, text/plain, */*",
+    "Content-Type": "application/x-www-form-urlencoded",
+    "User-Agent": USER_AGENT,
+  };
+}
+
+async function createLocalAuthorization(
+  state: string,
+): Promise<LocalAuthorization> {
+  const server = createServer();
+
+  return new Promise((resolve, reject) => {
+    let done = false;
+    let timer: ReturnType<typeof setTimeout> | undefined;
+    let complete!: (value: string | null) => void;
+    const wait = new Promise<string | null>((innerResolve) => {
+      complete = innerResolve;
+    });
+
+    const finish = (value: string | null) => {
+      if (done) return;
+      done = true;
+      if (timer) clearTimeout(timer);
+      if (server.listening) {
+        server.close(() => complete(value));
+        return;
+      }
+      complete(value);
+    };
+
+    server.on("request", (req, res) => {
+      const url = new URL(
+        req.url ?? "/",
+        `http://${req.headers.host ?? "localhost"}`,
+      );
+
+      if (url.pathname !== "/callback") {
+        res.writeHead(404, { "Content-Type": "text/plain; charset=utf-8" });
+        res.end("Not found");
+        return;
+      }
+
+      const code = url.searchParams.get("code");
+      const gotState = url.searchParams.get("state");
+      if (!code || !gotState) {
+        res.writeHead(400, { "Content-Type": "text/plain; charset=utf-8" });
+        res.end("Missing code or state");
+        return;
+      }
+
+      if (gotState !== state) {
+        res.writeHead(400, { "Content-Type": "text/plain; charset=utf-8" });
+        res.end("Invalid state");
+        finish(null);
+        return;
+      }
+
+      res.writeHead(200, { "Content-Type": "text/html; charset=utf-8" });
+      res.end(makeCallbackPage());
+      finish(url.toString());
+    });
+
+    server.once("error", reject);
+
+    server.listen(0, "127.0.0.1", () => {
+      const address = server.address();
+      if (!address || typeof address === "string") {
+        reject(new Error("Failed to allocate localhost callback port"));
+        return;
+      }
+
+      timer = setTimeout(() => finish(null), LOCAL_CALLBACK_TIMEOUT);
+      resolve({
+        redirectUri: `http://localhost:${address.port}/callback`,
+        waitForCallback: () => wait,
+      });
+    });
+  });
+}
+
+function makeCallbackPage(): string {
+  return `<!doctype html>
+<html>
+  <head><meta charset="utf-8" /><title>Authorization complete</title></head>
+  <body>
+    <h1>Authorization complete</h1>
+    <p>You can close this window and return to Pi.</p>
+  </body>
+</html>`;
+}
+
+async function generatePKCE(): Promise<{
+  verifier: string;
+  challenge: string;
+}> {
+  const bytes = new Uint8Array(32);
+  crypto.getRandomValues(bytes);
+  const verifier = toBase64Url(bytes);
+  const digest = await crypto.subtle.digest(
+    "SHA-256",
+    new TextEncoder().encode(verifier),
+  );
+  return {
+    verifier,
+    challenge: toBase64Url(new Uint8Array(digest)),
+  };
+}
+
+function toBase64Url(bytes: Uint8Array): string {
+  return Buffer.from(bytes)
+    .toString("base64")
+    .replace(/\+/g, "-")
+    .replace(/\//g, "_")
+    .replace(/=+$/g, "");
+}
+
+function parseAuthInput(input: string): ParsedAuthInput | null {
+  const text = input.trim();
+
+  try {
+    const url = new URL(text);
+    const code = url.searchParams.get("code");
+    const state = url.searchParams.get("state");
+    if (code && state) return { code, state };
+  } catch {}
+
+  const split = text.split("#");
+  if (split.length === 2 && split[0] && split[1]) {
+    return { code: split[0], state: split[1] };
+  }
+
+  const params = new URLSearchParams(text);
+  const code = params.get("code");
+  const state = params.get("state");
+  return code && state ? { code, state } : null;
+}

package/src/convert.ts

@@ -0,0 +1,187 @@
+import type { ContentBlockParam, MessageParam, ToolUnion } from "@anthropic-ai/sdk/resources/messages.js";
+
+type ToolResultContentBlock =
+  | { type: "text"; text: string }
+  | {
+      type: "image";
+      source: {
+        type: "base64";
+        media_type: "image/jpeg" | "image/png" | "image/gif" | "image/webp";
+        data: string;
+      };
+    };
+import type {
+  ImageContent,
+  Message,
+  TextContent,
+  ThinkingContent,
+  Tool,
+  ToolCall,
+  ToolResultMessage,
+} from "@mariozechner/pi-ai";
+import { sanitizeSurrogates } from "./prompt.js";
+
+export type IndexedBlock =
+  | (TextContent & { index: number })
+  | (ThinkingContent & { index: number; thinkingSignature?: string })
+  | (ToolCall & { index: number; partialJson: string });
+
+const claudeCodeTools = [
+  "Read",
+  "Write",
+  "Edit",
+  "Bash",
+  "Grep",
+  "Glob",
+  "AskUserQuestion",
+  "TodoWrite",
+  "WebFetch",
+  "WebSearch",
+] as const;
+const claudeCodeToolLookup = new Map(claudeCodeTools.map((name) => [name.toLowerCase(), name]));
+
+export function toClaudeCodeToolName(name: string): string {
+  return claudeCodeToolLookup.get(name.toLowerCase()) ?? name;
+}
+
+export function fromClaudeCodeToolName(name: string, tools?: Tool[]): string {
+  const lower = name.toLowerCase();
+  return tools?.find((tool) => tool.name.toLowerCase() === lower)?.name ?? name;
+}
+
+export function convertPiMessagesToAnthropic(
+  messages: Message[],
+  isOAuth: boolean,
+): MessageParam[] {
+  const params: MessageParam[] = [];
+
+  for (let i = 0; i < messages.length; i++) {
+    const message = messages[i];
+
+    if (message.role === "user") {
+      if (typeof message.content === "string") {
+        if (message.content.trim()) params.push({ role: "user", content: sanitizeSurrogates(message.content) });
+      } else {
+        const blocks: ContentBlockParam[] = message.content.map((item) =>
+          item.type === "text"
+            ? { type: "text", text: sanitizeSurrogates(item.text) }
+            : {
+                type: "image",
+                source: { type: "base64", media_type: item.mimeType as never, data: item.data },
+              },
+        );
+        if (blocks.length > 0) params.push({ role: "user", content: blocks });
+      }
+      continue;
+    }
+
+    if (message.role === "assistant") {
+      const blocks: ContentBlockParam[] = [];
+      for (const block of message.content) {
+        if (block.type === "text" && block.text.trim()) {
+          blocks.push({ type: "text", text: sanitizeSurrogates(block.text) });
+        } else if (block.type === "thinking" && block.thinking.trim()) {
+          if (block.thinkingSignature) {
+            blocks.push({
+              type: "thinking" as never,
+              thinking: sanitizeSurrogates(block.thinking),
+              signature: block.thinkingSignature,
+            });
+          } else {
+            blocks.push({ type: "text", text: sanitizeSurrogates(block.thinking) });
+          }
+        } else if (block.type === "toolCall") {
+          blocks.push({
+            type: "tool_use",
+            id: block.id,
+            name: isOAuth ? toClaudeCodeToolName(block.name) : block.name,
+            input: block.arguments,
+          });
+        }
+      }
+      if (blocks.length > 0) params.push({ role: "assistant", content: blocks });
+      continue;
+    }
+
+    if (message.role === "toolResult") {
+      const toolResults = [
+        {
+          type: "tool_result" as const,
+          tool_use_id: message.toolCallId,
+          content: convertToolResultContentToAnthropic(message.content),
+          is_error: message.isError,
+        },
+      ];
+
+      let j = i + 1;
+      while (j < messages.length && messages[j]?.role === "toolResult") {
+        const nextMessage = messages[j] as ToolResultMessage;
+        toolResults.push({
+          type: "tool_result" as const,
+          tool_use_id: nextMessage.toolCallId,
+          content: convertToolResultContentToAnthropic(nextMessage.content),
+          is_error: nextMessage.isError,
+        });
+        j++;
+      }
+      i = j - 1;
+      params.push({ role: "user", content: toolResults });
+    }
+  }
+
+  const last = params.at(-1);
+  if (last?.role === "user" && Array.isArray(last.content) && last.content.length > 0) {
+    const lastBlock = last.content[last.content.length - 1] as { cache_control?: { type: string } };
+    lastBlock.cache_control = { type: "ephemeral" };
+  }
+
+  return params;
+}
+
+export function convertPiToolsToAnthropic(tools: Tool[], isOAuth: boolean): ToolUnion[] {
+  return tools.map((tool) => ({
+    name: isOAuth ? toClaudeCodeToolName(tool.name) : tool.name,
+    description: tool.description,
+    input_schema: {
+      type: "object" as const,
+      properties: (tool.parameters as { properties?: Record<string, unknown> }).properties ?? {},
+      required: (tool.parameters as { required?: string[] }).required ?? [],
+    },
+  }));
+}
+
+function convertToolResultContentToAnthropic(
+  content: (TextContent | ImageContent)[],
+): string | ToolResultContentBlock[] {
+  const hasImages = content.some((block) => block.type === "image");
+  if (!hasImages) {
+    return sanitizeSurrogates(
+      content
+        .filter((block): block is TextContent => block.type === "text")
+        .map((block) => block.text)
+        .join("\n"),
+    );
+  }
+
+  const blocks = content.map((block) => {
+    if (block.type === "text") return { type: "text" as const, text: sanitizeSurrogates(block.text) };
+    return {
+      type: "image" as const,
+      source: {
+        type: "base64" as const,
+        media_type: block.mimeType as ToolResultContentBlock extends { type: "image"; source: infer S }
+          ? S extends { media_type: infer M }
+            ? M
+            : never
+          : never,
+        data: block.data,
+      },
+    };
+  });
+
+  if (!blocks.some((block) => block.type === "text")) {
+    blocks.unshift({ type: "text", text: "(see attached image)" });
+  }
+
+  return blocks;
+}

package/src/index.ts

@@ -0,0 +1,49 @@
+import type { ExtensionAPI } from "@mariozechner/pi-coding-agent";
+import { loginAnthropic, refreshAnthropicToken } from "./auth.js";
+import { streamAnthropicOAuth } from "./stream.js";
+
+const MODELS = [
+  {
+    id: "claude-opus-4-6",
+    name: "Claude Opus 4.6",
+    reasoning: true,
+    input: ["text", "image"] as ("text" | "image")[],
+    cost: { input: 0, output: 0, cacheRead: 0, cacheWrite: 0 },
+    contextWindow: 200000,
+    maxTokens: 128000,
+  },
+  {
+    id: "claude-sonnet-4-6",
+    name: "Claude Sonnet 4.6",
+    reasoning: true,
+    input: ["text", "image"] as ("text" | "image")[],
+    cost: { input: 0, output: 0, cacheRead: 0, cacheWrite: 0 },
+    contextWindow: 200000,
+    maxTokens: 64000,
+  },
+  {
+    id: "claude-haiku-4-5",
+    name: "Claude Haiku 4.5",
+    reasoning: true,
+    input: ["text", "image"] as ("text" | "image")[],
+    cost: { input: 0, output: 0, cacheRead: 0, cacheWrite: 0 },
+    contextWindow: 200000,
+    maxTokens: 64000,
+  },
+];
+
+export default function (pi: ExtensionAPI) {
+  pi.registerProvider("anthropic", {
+    baseUrl: "https://api.anthropic.com",
+    apiKey: "ANTHROPIC_MAX_API_KEY",
+    api: "anthropic-max-api",
+    models: [...MODELS],
+    oauth: {
+      name: "Claude Pro/Max",
+      login: loginAnthropic,
+      refreshToken: refreshAnthropicToken,
+      getApiKey: (credentials) => credentials.access,
+    },
+    streamSimple: streamAnthropicOAuth,
+  });
+}

package/src/prompt.ts

@@ -0,0 +1,58 @@
+const CLAUDE_CODE_IDENTITY =
+  "You are Claude Code, Anthropic's official CLI for Claude.";
+const PI_REMOVAL_ANCHORS = [
+  "pi-coding-agent",
+  "@mariozechner/pi-coding-agent",
+  "badlogic/pi-mono",
+] as const;
+
+type MessageContentBlock = {
+  type: string;
+  text?: string;
+  [key: string]: unknown;
+};
+
+export function sanitizeSurrogates(text: string): string {
+  return text.replace(/[\uD800-\uDFFF]/g, "\uFFFD");
+}
+
+export function buildAnthropicSystemPrompt(
+  systemPrompt: string | undefined,
+  isOAuth: boolean,
+): MessageContentBlock[] | undefined {
+  const blocks: MessageContentBlock[] = [];
+
+  if (isOAuth) {
+    blocks.push({
+      type: "text",
+      text: CLAUDE_CODE_IDENTITY,
+      cache_control: { type: "ephemeral" },
+    });
+  }
+
+  const sanitized = systemPrompt ? sanitizeSystemText(systemPrompt) : "";
+  if (sanitized) {
+    blocks.push({
+      type: "text",
+      text: sanitized,
+      cache_control: { type: "ephemeral" },
+    });
+  }
+
+  return blocks.length > 0 ? blocks : undefined;
+}
+
+function sanitizeSystemText(text: string): string {
+  const paragraphs = text.split(/\n\n+/);
+  const filtered = paragraphs.filter((paragraph) => {
+    const lower = paragraph.toLowerCase();
+    if (lower.includes("you are pi")) return false;
+    return !PI_REMOVAL_ANCHORS.some((anchor) => paragraph.includes(anchor));
+  });
+
+  return filtered
+    .join("\n\n")
+    .replace(/\bpi\b/g, "Claude Code")
+    .replace(/\bPi\b/g, "Claude Code")
+    .trim();
+}

package/src/stream.ts

@@ -0,0 +1,358 @@
+import Anthropic from "@anthropic-ai/sdk";
+import type { MessageCreateParamsStreaming } from "@anthropic-ai/sdk/resources/messages.js";
+import {
+  type Api,
+  type AssistantMessage,
+  type AssistantMessageEventStream,
+  calculateCost,
+  type Context,
+  createAssistantMessageEventStream,
+  type Model,
+  type SimpleStreamOptions,
+  type StopReason,
+} from "@mariozechner/pi-ai";
+import { USER_AGENT, isClaudeOAuthAccessToken } from "./auth.js";
+import {
+  convertPiMessagesToAnthropic,
+  convertPiToolsToAnthropic,
+  fromClaudeCodeToolName,
+  type IndexedBlock,
+} from "./convert.js";
+import { buildAnthropicSystemPrompt } from "./prompt.js";
+
+const REQUIRED_BETAS = [
+  "claude-code-20250219",
+  "oauth-2025-04-20",
+  "fine-grained-tool-streaming-2025-05-14",
+  "interleaved-thinking-2025-05-14",
+] as const;
+
+function mapStopReason(reason: string | null | undefined): StopReason {
+  switch (reason) {
+    case "end_turn":
+    case "pause_turn":
+    case "stop_sequence":
+      return "stop";
+    case "max_tokens":
+      return "length";
+    case "tool_use":
+      return "toolUse";
+    default:
+      return "error";
+  }
+}
+
+function makeDefaultHeaders(
+  isOAuth: boolean,
+  options?: SimpleStreamOptions,
+): Record<string, string> {
+  const headers: Record<string, string> = {
+    accept: "application/json",
+    "anthropic-dangerous-direct-browser-access": "true",
+  };
+
+  if (isOAuth) {
+    headers["anthropic-beta"] = REQUIRED_BETAS.join(",");
+    headers["user-agent"] = USER_AGENT;
+    headers["x-app"] = "cli";
+  } else {
+    headers["anthropic-beta"] = [
+      "fine-grained-tool-streaming-2025-05-14",
+      "interleaved-thinking-2025-05-14",
+    ].join(",");
+  }
+
+  if (options?.headers) {
+    for (const [key, value] of Object.entries(options.headers))
+      headers[key] = value;
+  }
+
+  return headers;
+}
+
+export function streamAnthropicOAuth(
+  model: Model<Api>,
+  context: Context,
+  options?: SimpleStreamOptions,
+): AssistantMessageEventStream {
+  const stream = createAssistantMessageEventStream();
+
+  void (async () => {
+    const output: AssistantMessage = {
+      role: "assistant",
+      content: [],
+      api: model.api,
+      provider: model.provider,
+      model: model.id,
+      usage: {
+        input: 0,
+        output: 0,
+        cacheRead: 0,
+        cacheWrite: 0,
+        totalTokens: 0,
+        cost: { input: 0, output: 0, cacheRead: 0, cacheWrite: 0, total: 0 },
+      },
+      stopReason: "stop",
+      timestamp: Date.now(),
+    };
+
+    try {
+      const apiKey = options?.apiKey ?? "";
+      const isOAuth = isClaudeOAuthAccessToken(apiKey);
+      const defaultHeaders = makeDefaultHeaders(isOAuth, options);
+
+      if (isOAuth) defaultHeaders.authorization = `Bearer ${apiKey}`;
+
+      const client = new Anthropic({
+        baseURL: model.baseUrl,
+        apiKey: isOAuth ? undefined : apiKey,
+        authToken: isOAuth ? apiKey : undefined,
+        defaultHeaders,
+        dangerouslyAllowBrowser: true,
+      });
+
+      const params: MessageCreateParamsStreaming = {
+        model: model.id,
+        messages: convertPiMessagesToAnthropic(context.messages, isOAuth),
+        max_tokens: options?.maxTokens || Math.floor(model.maxTokens / 3),
+        stream: true,
+      };
+
+      const system = buildAnthropicSystemPrompt(context.systemPrompt, isOAuth);
+      if (system) params.system = system as never;
+      if (context.tools?.length)
+        params.tools = convertPiToolsToAnthropic(context.tools, isOAuth);
+
+      if (options?.reasoning && model.reasoning) {
+        const defaultBudgets: Record<string, number> = {
+          minimal: 1024,
+          low: 4096,
+          medium: 10240,
+          high: 20480,
+          xhigh: 32000,
+        };
+        const customBudget =
+          options.thinkingBudgets?.[
+            options.reasoning as keyof typeof options.thinkingBudgets
+          ];
+        params.thinking = {
+          type: "enabled",
+          budget_tokens:
+            customBudget ?? defaultBudgets[options.reasoning] ?? 10240,
+        };
+      }
+
+      const anthropicStream = client.messages.stream(params, {
+        signal: options?.signal,
+      });
+      stream.push({ type: "start", partial: output });
+
+      const blocks = output.content as IndexedBlock[];
+
+      for await (const event of anthropicStream) {
+        if (event.type === "message_start") {
+          output.usage.input = event.message.usage.input_tokens || 0;
+          output.usage.output = event.message.usage.output_tokens || 0;
+          output.usage.cacheRead =
+            (event.message.usage as { cache_read_input_tokens?: number })
+              .cache_read_input_tokens || 0;
+          output.usage.cacheWrite =
+            (event.message.usage as { cache_creation_input_tokens?: number })
+              .cache_creation_input_tokens || 0;
+          output.usage.totalTokens =
+            output.usage.input +
+            output.usage.output +
+            output.usage.cacheRead +
+            output.usage.cacheWrite;
+          calculateCost(model, output.usage);
+          continue;
+        }
+
+        if (event.type === "content_block_start") {
+          if (event.content_block.type === "text") {
+            output.content.push({
+              type: "text",
+              text: "",
+              index: event.index,
+            } as IndexedBlock);
+            stream.push({
+              type: "text_start",
+              contentIndex: output.content.length - 1,
+              partial: output,
+            });
+          } else if (event.content_block.type === "thinking") {
+            output.content.push({
+              type: "thinking",
+              thinking: "",
+              thinkingSignature: "",
+              index: event.index,
+            } as IndexedBlock);
+            stream.push({
+              type: "thinking_start",
+              contentIndex: output.content.length - 1,
+              partial: output,
+            });
+          } else if (event.content_block.type === "tool_use") {
+            output.content.push({
+              type: "toolCall",
+              id: event.content_block.id,
+              name: isOAuth
+                ? fromClaudeCodeToolName(
+                    event.content_block.name,
+                    context.tools,
+                  )
+                : event.content_block.name,
+              arguments: {},
+              partialJson: "",
+              index: event.index,
+            } as IndexedBlock);
+            stream.push({
+              type: "toolcall_start",
+              contentIndex: output.content.length - 1,
+              partial: output,
+            });
+          }
+          continue;
+        }
+
+        if (event.type === "content_block_delta") {
+          const contentIndex = blocks.findIndex(
+            (block) => block.index === event.index,
+          );
+          const block = blocks[contentIndex];
+          if (!block) continue;
+
+          if (event.delta.type === "text_delta" && block.type === "text") {
+            block.text += event.delta.text;
+            stream.push({
+              type: "text_delta",
+              contentIndex,
+              delta: event.delta.text,
+              partial: output,
+            });
+          } else if (
+            event.delta.type === "thinking_delta" &&
+            block.type === "thinking"
+          ) {
+            block.thinking += event.delta.thinking;
+            stream.push({
+              type: "thinking_delta",
+              contentIndex,
+              delta: event.delta.thinking,
+              partial: output,
+            });
+          } else if (
+            event.delta.type === "signature_delta" &&
+            block.type === "thinking"
+          ) {
+            block.thinkingSignature =
+              (block.thinkingSignature || "") + event.delta.signature;
+          } else if (
+            event.delta.type === "input_json_delta" &&
+            block.type === "toolCall"
+          ) {
+            block.partialJson += event.delta.partial_json;
+            try {
+              block.arguments = JSON.parse(block.partialJson) as Record<
+                string,
+                unknown
+              >;
+            } catch {}
+            stream.push({
+              type: "toolcall_delta",
+              contentIndex,
+              delta: event.delta.partial_json,
+              partial: output,
+            });
+          }
+          continue;
+        }
+
+        if (event.type === "content_block_stop") {
+          const contentIndex = blocks.findIndex(
+            (block) => block.index === event.index,
+          );
+          const block = blocks[contentIndex];
+          if (!block) continue;
+
+          delete (block as { index?: number }).index;
+          if (block.type === "text") {
+            stream.push({
+              type: "text_end",
+              contentIndex,
+              content: block.text,
+              partial: output,
+            });
+          } else if (block.type === "thinking") {
+            stream.push({
+              type: "thinking_end",
+              contentIndex,
+              content: block.thinking,
+              partial: output,
+            });
+          } else if (block.type === "toolCall") {
+            try {
+              block.arguments = JSON.parse(block.partialJson) as Record<
+                string,
+                unknown
+              >;
+            } catch {}
+            delete (block as { partialJson?: string }).partialJson;
+            stream.push({
+              type: "toolcall_end",
+              contentIndex,
+              toolCall: block,
+              partial: output,
+            });
+          }
+          continue;
+        }
+
+        if (event.type === "message_delta") {
+          output.stopReason = mapStopReason(event.delta.stop_reason);
+          output.usage.input =
+            (event.usage as { input_tokens?: number }).input_tokens ||
+            output.usage.input;
+          output.usage.output =
+            (event.usage as { output_tokens?: number }).output_tokens ||
+            output.usage.output;
+          output.usage.cacheRead =
+            (event.usage as { cache_read_input_tokens?: number })
+              .cache_read_input_tokens || 0;
+          output.usage.cacheWrite =
+            (event.usage as { cache_creation_input_tokens?: number })
+              .cache_creation_input_tokens || 0;
+          output.usage.totalTokens =
+            output.usage.input +
+            output.usage.output +
+            output.usage.cacheRead +
+            output.usage.cacheWrite;
+          calculateCost(model, output.usage);
+        }
+      }
+
+      if (options?.signal?.aborted) throw new Error("Request aborted");
+      stream.push({
+        type: "done",
+        reason: output.stopReason as "stop" | "length" | "toolUse",
+        message: output,
+      });
+      stream.end();
+    } catch (error) {
+      for (const block of output.content as Array<{
+        index?: number;
+        partialJson?: string;
+      }>) {
+        delete block.index;
+        delete block.partialJson;
+      }
+      output.stopReason = options?.signal?.aborted ? "aborted" : "error";
+      output.errorMessage =
+        error instanceof Error ? error.message : String(error);
+      stream.push({ type: "error", reason: output.stopReason, error: output });
+      stream.end();
+    }
+  })();
+
+  return stream;
+}