pi-anthropic-oauth 0.1.8 → 0.1.10

package/README.md

@@ -1,13 +1,20 @@
-# Pi Anthropic OAuth
+# 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.
+Use Claude Pro/Max in Pi with browser OAuth.
 
-> [!WARNING]
-> Use this at your own risk. This may go against Anthropic's terms.
+## Features
+
+- Claude Pro/Max login from `/login anthropic`
+- Automatic token refresh
+- Claude Code-compatible OAuth headers and prompt shaping
+- No API key or extra usage needed.
+- Uses Pi's Anthropic model registry
+- Adds Claude Opus 4.7 by default
+- Auto-creates `~/.Claude Code` → `~/.pi` symlink when missing
 
-## Install
+## Quick start
 
 ```bash
 pi install npm:pi-anthropic-oauth
@@ -25,11 +32,42 @@ Choose:
 Claude Pro/Max
 ```
 
-## Notes
+> [!WARNING]
+> Use at your own risk. This may go against Anthropic's terms.
+
+> [!NOTE]
+> Anthropic auth changes are closely monitored for quick compatibility updates.
+
+## Extra models
+
+To add another Anthropic model, create `~/.pi/agent/models.json`:
+
+```json
+{
+  "providers": {
+    "anthropic": {
+      "baseUrl": "https://api.anthropic.com",
+      "apiKey": "REQUIRED_BY_PI_FOR_CUSTOM_MODELS",
+      "api": "anthropic-messages",
+      "models": [
+        {
+          "id": "your-model-id",
+          "name": "Your Model Name"
+        }
+      ]
+    }
+  }
+}
+```
+
+> [!NOTE]
+> 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 anthropic`, so `apiKey` is present to satisfy Pi's config requirements and does not need to be a valid Anthropic API key.
+
+## Troubleshooting
 
-- sends Claude Code-like OAuth headers
-- rewrites Pi system identity where needed
-- auto-creates `~/.Claude Code` → `~/.pi` symlink
+- Re-run `/login anthropic` if auth looks stale
+- If local callback login does not complete, paste the final callback URL or `code#state` when prompted
+- If something breaks, please open an issue with your Pi version, extension version, and error output
 
 ## License
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "pi-anthropic-oauth",
-  "version": "0.1.8",
+  "version": "0.1.10",
   "description": "Claude Pro/Max OAuth extension for Pi",
   "type": "module",
   "license": "MIT",

package/src/auth.ts

@@ -152,7 +152,6 @@ export async function refreshAnthropicToken(
           grant_type: "refresh_token",
           client_id: CLIENT_ID,
           refresh_token: credentials.refresh,
-          scope: SCOPES,
         }),
       },
       "Token refresh",

package/src/convert.ts

@@ -73,10 +73,33 @@ export function convertPiMessagesToAnthropic(
     return candidate;
   };
 
+  // Anthropic requires every `tool_use` block to be IMMEDIATELY followed by a
+  // user message containing a matching `tool_result` for the same id. Aborted
+  // / errored assistant turns or partial histories can leave orphan tool_uses
+  // behind, which causes the API to reject the next request with:
+  //   `tool_use` ids were found without `tool_result` blocks immediately after
+  // We track outstanding tool_use ids from the last assistant message and
+  // synthesize "No result provided" results for any that aren't satisfied by
+  // the time we emit the next user message (or finish the history).
+  let pendingToolUseIds: string[] = [];
+
+  const flushPendingToolResults = () => {
+    if (pendingToolUseIds.length === 0) return;
+    const syntheticBlocks: ContentBlockParam[] = pendingToolUseIds.map((id) => ({
+      type: "tool_result",
+      tool_use_id: id,
+      content: "No result provided",
+      is_error: true,
+    }));
+    params.push({ role: "user", content: syntheticBlocks });
+    pendingToolUseIds = [];
+  };
+
   for (let i = 0; i < messages.length; i++) {
     const message = messages[i];
 
     if (message.role === "user") {
+      flushPendingToolResults();
       if (typeof message.content === "string") {
         if (message.content.trim()) params.push({ role: "user", content: sanitizeSurrogates(message.content) });
       } else {
@@ -94,45 +117,85 @@ export function convertPiMessagesToAnthropic(
     }
 
     if (message.role === "assistant") {
+      // Skip aborted / errored assistant turns entirely. Their content may
+      // include partial tool_use blocks that will never get a matching
+      // tool_result, which would poison every subsequent request.
+      if (message.stopReason === "aborted" || message.stopReason === "error") {
+        continue;
+      }
+
+      // Defensive: if the previous assistant turn had unresolved tool_uses and
+      // the next message is another assistant (shouldn't normally happen),
+      // patch them up before emitting the new assistant turn.
+      flushPendingToolResults();
+
       const blocks: ContentBlockParam[] = [];
+      const emittedToolUseIds: string[] = [];
       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 === "toolCall") {
+          const anthropicId = getAnthropicToolId(block.id);
           blocks.push({
             type: "tool_use",
-            id: getAnthropicToolId(block.id),
+            id: anthropicId,
             name: isOAuth ? toClaudeCodeToolName(block.name) : block.name,
-            input: block.arguments,
+            input: block.arguments ?? {},
           });
+          emittedToolUseIds.push(anthropicId);
         }
       }
-      if (blocks.length > 0) params.push({ role: "assistant", content: blocks });
+      if (blocks.length > 0) {
+        params.push({ role: "assistant", content: blocks });
+        pendingToolUseIds = emittedToolUseIds;
+      }
       continue;
     }
 
     if (message.role === "toolResult") {
-      const toolResults = [
-        {
-          type: "tool_result" as const,
-          tool_use_id: getAnthropicToolId(message.toolCallId),
-          content: convertToolResultContentToAnthropic(message.content),
-          is_error: message.isError,
-        },
-      ];
+      const toolResults: ContentBlockParam[] = [];
+      const satisfiedIds = new Set<string>();
+
+      const firstId = getAnthropicToolId(message.toolCallId);
+      toolResults.push({
+        type: "tool_result",
+        tool_use_id: firstId,
+        content: convertToolResultContentToAnthropic(message.content),
+        is_error: message.isError,
+      });
+      satisfiedIds.add(firstId);
 
       let j = i + 1;
       while (j < messages.length && messages[j]?.role === "toolResult") {
         const nextMessage = messages[j] as ToolResultMessage;
+        const nextId = getAnthropicToolId(nextMessage.toolCallId);
         toolResults.push({
-          type: "tool_result" as const,
-          tool_use_id: getAnthropicToolId(nextMessage.toolCallId),
+          type: "tool_result",
+          tool_use_id: nextId,
           content: convertToolResultContentToAnthropic(nextMessage.content),
           is_error: nextMessage.isError,
         });
+        satisfiedIds.add(nextId);
         j++;
       }
       i = j - 1;
+
+      // Synthesize "No result provided" for any tool_use from the last
+      // assistant message that wasn't covered by the toolResult run. They
+      // must live in the SAME user message as the real tool_results so that
+      // every tool_use is immediately followed by matching results.
+      for (const id of pendingToolUseIds) {
+        if (!satisfiedIds.has(id)) {
+          toolResults.push({
+            type: "tool_result",
+            tool_use_id: id,
+            content: "No result provided",
+            is_error: true,
+          });
+        }
+      }
+      pendingToolUseIds = [];
+
       params.push({ role: "user", content: toolResults });
     }
   }

package/src/index.ts

@@ -1,58 +1,27 @@
 import { existsSync, symlinkSync } from "node:fs";
 import { homedir } from "node:os";
 import { join } from "node:path";
-import type { ExtensionAPI, ProviderConfig } from "@mariozechner/pi-coding-agent";
+import {
+  AuthStorage,
+  ModelRegistry,
+  type ExtensionAPI,
+  type ProviderConfig,
+} from "@mariozechner/pi-coding-agent";
 import type { OAuthCredentials } from "@mariozechner/pi-ai";
 import { loginAnthropic, refreshAnthropicToken } from "./auth.js";
 import { streamAnthropicOAuth } from "./stream.js";
 
-const MODELS = [
-  {
-    id: "claude-opus-4-7",
-    name: "Claude Opus 4.7",
-    reasoning: true,
-    input: ["text", "image"] as ("text" | "image")[],
-    cost: { input: 0, output: 0, cacheRead: 0, cacheWrite: 0 },
-    contextWindow: 1000000,
-    maxTokens: 128000,
-  },
-  {
-    id: "claude-opus-4-6",
-    name: "Claude Opus 4.6",
-    reasoning: true,
-    input: ["text", "image"] as ("text" | "image")[],
-    cost: { input: 5, output: 25, cacheRead: 0.5, cacheWrite: 6.25 },
-    contextWindow: 1000000,
-    maxTokens: 128000,
-  },
-  {
-    id: "claude-sonnet-4-6",
-    name: "Claude Sonnet 4.6",
-    reasoning: true,
-    input: ["text", "image"] as ("text" | "image")[],
-    cost: { input: 3, output: 15, cacheRead: 0.3, cacheWrite: 3.75 },
-    contextWindow: 1000000,
-    maxTokens: 64000,
-  },
-  {
-    id: "claude-haiku-4-5",
-    name: "Claude Haiku 4.5",
-    reasoning: true,
-    input: ["text", "image"] as ("text" | "image")[],
-    cost: { input: 1, output: 5, cacheRead: 0.1, cacheWrite: 1.25 },
-    contextWindow: 200000,
-    maxTokens: 64000,
-  },
-  {
-    id: "claude-opus-4-5-20251101",
-    name: "Claude Opus 4.5",
-    reasoning: true,
-    input: ["text", "image"] as ("text" | "image")[],
-    cost: { input: 5, output: 25, cacheRead: 0.5, cacheWrite: 6.25 },
-    contextWindow: 200000,
-    maxTokens: 64000,
-  }
-];
+const DEFAULT_OPUS_4_7: NonNullable<ProviderConfig["models"]>[number] = {
+  id: "claude-opus-4-7",
+  name: "Claude Opus 4.7",
+  api: "anthropic-messages",
+  reasoning: true,
+  input: ["text", "image"],
+  cost: { input: 5, output: 25, cacheRead: 0.5, cacheWrite: 6.25 },
+  contextWindow: 1000000,
+  maxTokens: 128000,
+  compat: undefined,
+};
 
 function ensureClaudeCodeSymlink() {
   const target = join(homedir(), ".pi");
@@ -64,13 +33,38 @@ 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")
+    .map((model) => ({
+      id: model.id,
+      name: model.name,
+      api: model.api ?? "anthropic-messages",
+      reasoning: model.reasoning,
+      input: model.input,
+      cost: model.cost,
+      contextWindow: model.contextWindow,
+      maxTokens: model.maxTokens,
+      compat: model.compat,
+    }));
+
+  if (!models.some((model) => model.id === DEFAULT_OPUS_4_7.id)) {
+    models.push(DEFAULT_OPUS_4_7);
+  }
+
+  return models;
+}
+
 export default function (pi: ExtensionAPI) {
   ensureClaudeCodeSymlink();
+  const models = getAnthropicModels();
+
   pi.registerProvider("anthropic", {
     baseUrl: "https://api.anthropic.com",
-    apiKey: "ANTHROPIC_MAX_API_KEY",
-    api: "anthropic-max-api",
-    models: [...MODELS],
+    api: "anthropic-messages",
+    models,
     oauth: {
       name: "Claude Pro/Max",
       usesCallbackServer: true,

package/src/stream.ts

@@ -11,7 +11,7 @@ import {
   type SimpleStreamOptions,
   type StopReason,
 } from "@mariozechner/pi-ai";
-import { USER_AGENT } from "./auth.js";
+import { isClaudeOAuthAccessToken, USER_AGENT } from "./auth.js";
 import {
   convertPiMessagesToAnthropic,
   convertPiToolsToAnthropic,
@@ -105,8 +105,12 @@ export function streamAnthropicOAuth(
     };
 
     try {
-      const apiKey = options?.apiKey ?? "";
-      const isOAuth = true;
+      const apiKey = options?.apiKey;
+      if (!apiKey) {
+        throw new Error("No Anthropic auth available. Run /login anthropic.");
+      }
+
+      const isOAuth = isClaudeOAuthAccessToken(apiKey);
       const defaultHeaders = makeDefaultHeaders(isOAuth, options);
 
       if (isOAuth) defaultHeaders.authorization = `Bearer ${apiKey}`;