pi-anthropic-oauth 0.1.17 → 0.2.1

package/README.md

@@ -4,6 +4,9 @@
 
 Use Claude Pro/Max in Pi with browser OAuth.
 
+> [!IMPORTANT]
+> This release requires Pi 0.80.8 or later in the 0.80.x release line.
+
 ## Features
 
 - Claude Pro/Max login from `/login`
@@ -34,6 +37,8 @@ Claude Pro/Max
 
 Complete the browser login. After login, select an Anthropic model in Pi.
 
+When the extension is active, `/login` includes `Claude Pro/Max` and Anthropic models show `(sub)` after OAuth login.
+
 Update with:
 
 ```bash
@@ -96,7 +101,7 @@ To add another Anthropic model, create `~/.pi/agent/models.json`:
 ```
 
 > [!NOTE]
-> Opus 4.8 and Fable 5 are registered automatically. Fable 5 works on Pro/Max through July 7, 2026; after that Anthropic says continued use requires extra usage credits unless extended.
+> Opus 4.8 and Fable 5 are included in Pi's built-in Anthropic model catalog.
 >
 > Pi requires `baseUrl`, `apiKey`, and `api` when defining custom models in `models.json`. With this extension, requests normally authenticate through Claude Pro/Max OAuth after `/login`, so `apiKey` is only a placeholder to satisfy Pi's config requirements and does not need to be a valid Anthropic API key.
 >

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "pi-anthropic-oauth",
-  "version": "0.1.17",
+  "version": "0.2.1",
   "description": "Claude Pro/Max OAuth extension for Pi",
   "type": "module",
   "license": "MIT",
@@ -38,12 +38,12 @@
     "@anthropic-ai/sdk": "^0.52.0"
   },
   "peerDependencies": {
-    "@earendil-works/pi-ai": "*",
-    "@earendil-works/pi-coding-agent": "*"
+    "@earendil-works/pi-ai": "^0.80.8",
+    "@earendil-works/pi-coding-agent": "^0.80.8"
   },
   "devDependencies": {
-    "@earendil-works/pi-ai": "^0.74.0",
-    "@earendil-works/pi-coding-agent": "^0.74.0",
+    "@earendil-works/pi-ai": "^0.80.8",
+    "@earendil-works/pi-coding-agent": "^0.80.8",
     "typescript": "^5.9.3"
   }
 }

package/src/convert.ts

@@ -11,8 +11,10 @@ type ToolResultContentBlock =
       };
     };
 import type {
+  Api,
   ImageContent,
   Message,
+  Model,
   TextContent,
   ThinkingContent,
   Tool,
@@ -52,6 +54,7 @@ export function fromClaudeCodeToolName(name: string, tools?: Tool[]): string {
 export function convertPiMessagesToAnthropic(
   messages: Message[],
   isOAuth: boolean,
+  model: Pick<Model<Api>, "provider" | "api" | "id">,
 ): MessageParam[] {
   const params: MessageParam[] = [];
   const toolIdMap = new Map<string, string>();
@@ -131,9 +134,34 @@ export function convertPiMessagesToAnthropic(
 
       const blocks: ContentBlockParam[] = [];
       const emittedToolUseIds: string[] = [];
+      const isSameModel =
+        message.provider === model.provider &&
+        message.api === model.api &&
+        message.model === model.id;
       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") {
+          const thinkingSignature = block.thinkingSignature?.trim();
+          if (block.redacted) {
+            if (isSameModel && thinkingSignature) {
+              blocks.push({
+                type: "redacted_thinking",
+                data: block.thinkingSignature!,
+              });
+            }
+          } else if (isSameModel && thinkingSignature) {
+            blocks.push({
+              type: "thinking",
+              thinking: sanitizeSurrogates(block.thinking),
+              signature: block.thinkingSignature!,
+            });
+          } else if (block.thinking.trim()) {
+            blocks.push({
+              type: "text",
+              text: sanitizeSurrogates(block.thinking),
+            });
+          }
         } else if (block.type === "toolCall") {
           const anthropicId = getAnthropicToolId(block.id);
           blocks.push({

package/src/index.ts

@@ -2,8 +2,6 @@ import { existsSync, symlinkSync } from "node:fs";
 import { homedir } from "node:os";
 import { join } from "node:path";
 import {
-  AuthStorage,
-  ModelRegistry,
   type ExtensionAPI,
   type ProviderConfig,
 } from "@earendil-works/pi-coding-agent";
@@ -11,33 +9,6 @@ import type { OAuthCredentials } from "@earendil-works/pi-ai";
 import { loginAnthropic, refreshAnthropicToken } from "./auth.js";
 import { streamAnthropicOAuth } from "./stream.js";
 
-const DEFAULT_MODELS: NonNullable<ProviderConfig["models"]> = [
-  {
-    id: "claude-opus-4-8",
-    name: "Claude Opus 4.8",
-    api: "anthropic-messages",
-    reasoning: true,
-    thinkingLevelMap: { xhigh: "xhigh" },
-    input: ["text", "image"],
-    cost: { input: 5, output: 25, cacheRead: 0.5, cacheWrite: 6.25 },
-    contextWindow: 1000000,
-    maxTokens: 128000,
-    compat: undefined,
-  },
-  {
-    id: "claude-fable-5",
-    name: "Claude Fable 5",
-    api: "anthropic-messages",
-    reasoning: true,
-    thinkingLevelMap: { xhigh: "xhigh" },
-    input: ["text", "image"],
-    cost: { input: 10, output: 50, cacheRead: 1, cacheWrite: 12.5 },
-    contextWindow: 1000000,
-    maxTokens: 128000,
-    compat: undefined,
-  },
-];
-
 function ensureClaudeCodeSymlink() {
   const target = join(homedir(), ".pi");
   const link = join(homedir(), ".Claude Code");
@@ -48,36 +19,12 @@ function ensureClaudeCodeSymlink() {
   }
 }
 
-function getAnthropicModels(): NonNullable<ProviderConfig["models"]> {
-  const modelRegistry = ModelRegistry.create(AuthStorage.inMemory());
-  const models: NonNullable<ProviderConfig["models"]> = modelRegistry
-    .getAll()
-    .filter((model) => model.provider === "anthropic")
-    // Spread the full registry model so every field (thinkingLevelMap,
-    // baseUrl, headers, compat, and anything added in future) propagates
-    // automatically instead of being silently dropped by a hand-picked list.
-    .map((model) => ({
-      ...model,
-      api: model.api ?? "anthropic-messages",
-    }));
-
-  for (const defaultModel of DEFAULT_MODELS) {
-    if (!models.some((model) => model.id === defaultModel.id)) {
-      models.push(defaultModel);
-    }
-  }
-
-  return models;
-}
-
 export default function (pi: ExtensionAPI) {
   ensureClaudeCodeSymlink();
-  const models = getAnthropicModels();
 
   pi.registerProvider("anthropic", {
     baseUrl: "https://api.anthropic.com",
     api: "anthropic-messages",
-    models,
     oauth: {
       name: "Claude Pro/Max",
       usesCallbackServer: true,

package/src/stream.ts

@@ -10,7 +10,6 @@ import {
   type Model,
   type SimpleStreamOptions,
   type StopReason,
-  streamSimpleAnthropic,
 } from "@earendil-works/pi-ai";
 import { isClaudeOAuthAccessToken, USER_AGENT } from "./auth.js";
 import {
@@ -82,7 +81,11 @@ function makeDefaultHeaders(
       ) {
         continue;
       }
-      headers[key] = value;
+      const existingKey = Object.keys(headers).find(
+        (header) => header.toLowerCase() === normalizedKey,
+      );
+      if (existingKey) delete headers[existingKey];
+      if (value !== null) headers[key] = value;
     }
   }
 
@@ -94,16 +97,6 @@ export function streamAnthropicOAuth(
   context: Context,
   options?: SimpleStreamOptions,
 ): AssistantMessageEventStream {
-  // pi-ai keys streamSimple by `api`, so this runs for every anthropic-messages
-  // model (copilot, openrouter, …). Delegate non-anthropic providers.
-  if (model.provider !== "anthropic") {
-    return streamSimpleAnthropic(
-      model as Model<"anthropic-messages">,
-      context,
-      options,
-    );
-  }
-
   const stream = createAssistantMessageEventStream();
 
   void (async () => {
@@ -151,7 +144,7 @@ export function streamAnthropicOAuth(
 
       const params: MessageCreateParamsStreaming = {
         model: model.id,
-        messages: convertPiMessagesToAnthropic(context.messages, isOAuth),
+        messages: convertPiMessagesToAnthropic(context.messages, isOAuth, model),
         max_tokens: maxTokens,
         stream: true,
       };
@@ -255,6 +248,19 @@ export function streamAnthropicOAuth(
               contentIndex: output.content.length - 1,
               partial: output,
             });
+          } else if (event.content_block.type === "redacted_thinking") {
+            output.content.push({
+              type: "thinking",
+              thinking: "[Reasoning redacted]",
+              thinkingSignature: event.content_block.data,
+              redacted: true,
+              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",
@@ -385,6 +391,14 @@ export function streamAnthropicOAuth(
           output.usage.cacheWrite =
             (event.usage as { cache_creation_input_tokens?: number })
               .cache_creation_input_tokens || 0;
+          const thinkingTokens = (
+            event.usage as {
+              output_tokens_details?: { thinking_tokens?: number };
+            }
+          ).output_tokens_details?.thinking_tokens;
+          if (thinkingTokens != null) {
+            output.usage.reasoning = thinkingTokens;
+          }
           output.usage.totalTokens =
             output.usage.input +
             output.usage.output +