pi-anthropic-oauth 0.1.9 → 0.1.11

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,14 +32,13 @@ Choose:
 Claude Pro/Max
 ```
 
-## Notes
+> [!WARNING]
+> Use at your own risk. This may go against Anthropic's terms.
 
-- uses Pi's built-in Anthropic model list
-- sends Claude Code-like OAuth headers
-- rewrites Pi system identity where needed
-- auto-creates `~/.Claude Code` → `~/.pi` symlink
+> [!NOTE]
+> Anthropic auth changes are closely monitored for quick compatibility updates.
 
-## Custom models
+## Extra models
 
 To add another Anthropic model, create `~/.pi/agent/models.json`:
 
@@ -57,6 +63,12 @@ To add another Anthropic model, create `~/.pi/agent/models.json`:
 > [!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
+
+- 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
 
 MIT

package/package.json

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

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/stream.ts

@@ -10,6 +10,7 @@ import {
   type Model,
   type SimpleStreamOptions,
   type StopReason,
+  streamSimpleAnthropic,
 } from "@mariozechner/pi-ai";
 import { isClaudeOAuthAccessToken, USER_AGENT } from "./auth.js";
 import {
@@ -83,6 +84,16 @@ 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 () => {