pi-anthropic-oauth 0.1.2 → 0.1.4

package/package.json

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

package/src/auth.ts

@@ -17,6 +17,8 @@ const SCOPES = [
   "user:file_upload",
 ].join(" ");
 const USER_AGENT = "claude-code/2.1.97";
+const CALLBACK_PORT = 53692;
+const CALLBACK_HOST = "127.0.0.1";
 const LOCAL_CALLBACK_TIMEOUT = 5 * 60 * 1000;
 const MAX_TOKEN_RETRIES = 2;
 const INITIAL_RETRY_DELAY_MS = 5000;
@@ -27,6 +29,7 @@ type ParsedAuthInput = { code: string; state: string };
 type LocalAuthorization = {
   redirectUri: string;
   waitForCallback: () => Promise<string | null>;
+  cancel: () => void;
 };
 
 export function isClaudeOAuthAccessToken(apiKey: string): boolean {
@@ -49,12 +52,43 @@ export async function loginAnthropic(
     callbacks.onAuth({
       url: makeAuthorizeUrl(challenge, state, redirectUri),
       instructions:
-        "Complete authorization in the browser. Pi will try to capture the callback automatically.",
+        "Complete login in your browser. If the browser is on another machine, paste the final redirect URL here.",
     });
 
-    authInput = await localAuthorization.waitForCallback();
+    if (callbacks.onManualCodeInput) {
+      let manualInput: string | undefined;
+      let manualError: Error | undefined;
+      const manualPromise = callbacks
+        .onManualCodeInput()
+        .then((input) => {
+          manualInput = input;
+          localAuthorization.cancel();
+        })
+        .catch((err) => {
+          manualError =
+            err instanceof Error ? err : new Error(String(err));
+          localAuthorization.cancel();
+        });
+
+      const callbackResult = await localAuthorization.waitForCallback();
+
+      if (manualError) throw manualError;
+
+      if (callbackResult) {
+        authInput = callbackResult;
+      } else if (manualInput) {
+        authInput = manualInput;
+      }
+
+      if (!authInput) {
+        await manualPromise;
+        if (manualError) throw manualError;
+        if (manualInput) authInput = manualInput;
+      }
+    } else {
+      authInput = await localAuthorization.waitForCallback();
+    }
   } catch {
-    // Fall back to manual code entry when localhost callback setup fails.
   }
 
   if (!authInput) {
@@ -270,17 +304,12 @@ async function createLocalAuthorization(
 
     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;
-      }
-
+    server.listen(CALLBACK_PORT, CALLBACK_HOST, () => {
       timer = setTimeout(() => finish(null), LOCAL_CALLBACK_TIMEOUT);
       resolve({
-        redirectUri: `http://localhost:${address.port}/callback`,
+        redirectUri: `http://localhost:${CALLBACK_PORT}/callback`,
         waitForCallback: () => wait,
+        cancel: () => finish(null),
       });
     });
   });

package/src/convert.ts

@@ -54,6 +54,24 @@ export function convertPiMessagesToAnthropic(
   isOAuth: boolean,
 ): MessageParam[] {
   const params: MessageParam[] = [];
+  const toolIdMap = new Map<string, string>();
+  const usedToolIds = new Set<string>();
+
+  const getAnthropicToolId = (id: string): string => {
+    const existing = toolIdMap.get(id);
+    if (existing) return existing;
+
+    let base = sanitizeSurrogates(id).replace(/[^a-zA-Z0-9_-]/g, "_");
+    if (!base) base = "tool";
+    let candidate = base;
+    let suffix = 1;
+    while (usedToolIds.has(candidate)) {
+      candidate = `${base}_${suffix++}`;
+    }
+    usedToolIds.add(candidate);
+    toolIdMap.set(id, candidate);
+    return candidate;
+  };
 
   for (let i = 0; i < messages.length; i++) {
     const message = messages[i];
@@ -81,19 +99,11 @@ export function convertPiMessagesToAnthropic(
         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) });
-          }
+          blocks.push({ type: "text", text: sanitizeSurrogates(block.thinking) });
         } else if (block.type === "toolCall") {
           blocks.push({
             type: "tool_use",
-            id: block.id,
+            id: getAnthropicToolId(block.id),
             name: isOAuth ? toClaudeCodeToolName(block.name) : block.name,
             input: block.arguments,
           });
@@ -107,7 +117,7 @@ export function convertPiMessagesToAnthropic(
       const toolResults = [
         {
           type: "tool_result" as const,
-          tool_use_id: message.toolCallId,
+          tool_use_id: getAnthropicToolId(message.toolCallId),
           content: convertToolResultContentToAnthropic(message.content),
           is_error: message.isError,
         },
@@ -118,7 +128,7 @@ export function convertPiMessagesToAnthropic(
         const nextMessage = messages[j] as ToolResultMessage;
         toolResults.push({
           type: "tool_result" as const,
-          tool_use_id: nextMessage.toolCallId,
+          tool_use_id: getAnthropicToolId(nextMessage.toolCallId),
           content: convertToolResultContentToAnthropic(nextMessage.content),
           is_error: nextMessage.isError,
         });

package/src/index.ts

@@ -1,7 +1,8 @@
 import { existsSync, symlinkSync } from "node:fs";
 import { homedir } from "node:os";
 import { join } from "node:path";
-import type { ExtensionAPI } from "@mariozechner/pi-coding-agent";
+import type { ExtensionAPI, ProviderConfig } from "@mariozechner/pi-coding-agent";
+import type { OAuthCredentials } from "@mariozechner/pi-ai";
 import { loginAnthropic, refreshAnthropicToken } from "./auth.js";
 import { streamAnthropicOAuth } from "./stream.js";
 
@@ -54,10 +55,11 @@ export default function (pi: ExtensionAPI) {
     models: [...MODELS],
     oauth: {
       name: "Claude Pro/Max",
+      usesCallbackServer: true,
       login: loginAnthropic,
       refreshToken: refreshAnthropicToken,
-      getApiKey: (credentials) => credentials.access,
-    },
+      getApiKey: (credentials: OAuthCredentials) => credentials.access,
+    } as unknown as ProviderConfig["oauth"],
     streamSimple: streamAnthropicOAuth,
   });
 }

package/src/stream.ts

@@ -111,10 +111,13 @@ export function streamAnthropicOAuth(
         dangerouslyAllowBrowser: true,
       });
 
+      const maxTokens =
+        options?.maxTokens || Math.floor(model.maxTokens / 3);
+
       const params: MessageCreateParamsStreaming = {
         model: model.id,
         messages: convertPiMessagesToAnthropic(context.messages, isOAuth),
-        max_tokens: options?.maxTokens || Math.floor(model.maxTokens / 3),
+        max_tokens: maxTokens,
         stream: true,
       };
 
@@ -123,7 +126,7 @@ export function streamAnthropicOAuth(
       if (context.tools?.length)
         params.tools = convertPiToolsToAnthropic(context.tools, isOAuth);
 
-      if (options?.reasoning && model.reasoning) {
+      if (options?.reasoning && model.reasoning && maxTokens > 1) {
         const defaultBudgets: Record<string, number> = {
           minimal: 1024,
           low: 4096,
@@ -135,10 +138,12 @@ export function streamAnthropicOAuth(
           options.thinkingBudgets?.[
             options.reasoning as keyof typeof options.thinkingBudgets
           ];
+        const requestedBudget =
+          customBudget ?? defaultBudgets[options.reasoning] ?? 10240;
+
         params.thinking = {
           type: "enabled",
-          budget_tokens:
-            customBudget ?? defaultBudgets[options.reasoning] ?? 10240,
+          budget_tokens: Math.min(requestedBudget, maxTokens - 1),
         };
       }