@gotgenes/pi-anthropic-auth 0.4.6 → 0.5.0

package/src/request-shaping.ts

@@ -0,0 +1,294 @@
+import { createHash } from "node:crypto";
+import {
+  BILLING_HEADER_POSITIONS,
+  BILLING_HEADER_SALT,
+  CLAUDE_CODE_ENTRYPOINT,
+  CLAUDE_CODE_IDENTITY_PREFIX,
+  CLAUDE_CODE_VERSION,
+  MINIMAL_ANTHROPIC_OAUTH_PROMPT_PREFIX,
+} from "./constants";
+import { debugLog, isToolUseOnlyDebugEnabled } from "./debug";
+import { shapeSystemBlocks } from "./system-prompt-shaping";
+
+type TextBlock = {
+  type: "text";
+  text: string;
+  cache_control?: unknown;
+  [key: string]: unknown;
+};
+
+type MessageBlock = {
+  type?: string;
+  text?: string;
+  [key: string]: unknown;
+};
+
+type MessageParam = {
+  role?: string;
+  content?: string | MessageBlock[];
+  [key: string]: unknown;
+};
+
+type AnthropicPayload = {
+  model?: unknown;
+  messages?: unknown;
+  system?: unknown;
+  stream?: unknown;
+  [key: string]: unknown;
+};
+
+function isRecord(value: unknown): value is Record<string, unknown> {
+  return value !== null && typeof value === "object" && !Array.isArray(value);
+}
+
+function isAnthropicMessagesPayload(
+  payload: unknown,
+): payload is AnthropicPayload {
+  return (
+    isRecord(payload) &&
+    typeof payload.model === "string" &&
+    Array.isArray(payload.messages) &&
+    typeof payload.stream === "boolean"
+  );
+}
+
+function isOAuthAnthropicPayload(payload: AnthropicPayload): boolean {
+  if (!Array.isArray(payload.system)) {
+    return false;
+  }
+
+  return payload.system.some(hasOAuthAnthropicSystemMarker);
+}
+
+function hasOAuthAnthropicSystemMarker(block: unknown): boolean {
+  if (
+    !isRecord(block) ||
+    block.type !== "text" ||
+    typeof block.text !== "string"
+  ) {
+    return false;
+  }
+
+  return (
+    block.text.includes(CLAUDE_CODE_IDENTITY_PREFIX) ||
+    block.text.includes("x-anthropic-billing-header:") ||
+    block.text.startsWith(MINIMAL_ANTHROPIC_OAUTH_PROMPT_PREFIX)
+  );
+}
+
+function getFirstUserText(messages: MessageParam[]): string {
+  const firstUserMessage = messages.find((message) => message.role === "user");
+  if (!firstUserMessage) return "";
+
+  if (typeof firstUserMessage.content === "string") {
+    return firstUserMessage.content;
+  }
+
+  if (!Array.isArray(firstUserMessage.content)) {
+    return "";
+  }
+
+  const firstTextBlock = firstUserMessage.content.find(
+    (block) => block.type === "text" && typeof block.text === "string",
+  );
+
+  return typeof firstTextBlock?.text === "string" ? firstTextBlock.text : "";
+}
+
+function buildBillingHeaderValue(messages: MessageParam[]): string | undefined {
+  const messageText = getFirstUserText(messages);
+  if (!messageText) {
+    return undefined;
+  }
+
+  const cch = createHash("sha256")
+    .update(messageText)
+    .digest("hex")
+    .slice(0, 5);
+  const sampledCharacters = BILLING_HEADER_POSITIONS.map(
+    (index) => messageText[index] || "0",
+  ).join("");
+  const suffix = createHash("sha256")
+    .update(`${BILLING_HEADER_SALT}${sampledCharacters}${CLAUDE_CODE_VERSION}`)
+    .digest("hex")
+    .slice(0, 3);
+
+  return [
+    "x-anthropic-billing-header:",
+    `cc_version=${CLAUDE_CODE_VERSION}.${suffix};`,
+    `cc_entrypoint=${CLAUDE_CODE_ENTRYPOINT};`,
+    `cch=${cch};`,
+  ].join(" ");
+}
+
+function normalizeSystemBlock(block: unknown): TextBlock {
+  if (typeof block === "string") {
+    return { type: "text", text: block };
+  }
+
+  if (isRecord(block) && typeof block.text === "string") {
+    return {
+      ...block,
+      type: "text",
+      text: block.text,
+    };
+  }
+
+  return { type: "text", text: "" };
+}
+
+function prependBillingHeader(
+  system: unknown,
+  messages: MessageParam[],
+): unknown {
+  const billingHeader = buildBillingHeaderValue(messages);
+  if (!billingHeader) {
+    return system;
+  }
+
+  const systemBlocks = Array.isArray(system)
+    ? system.map(normalizeSystemBlock)
+    : system == null
+      ? []
+      : [normalizeSystemBlock(system)];
+
+  if (
+    systemBlocks.some((block) =>
+      block.text.includes("x-anthropic-billing-header:"),
+    )
+  ) {
+    return systemBlocks;
+  }
+
+  const billingBlock: TextBlock = { type: "text", text: billingHeader };
+
+  return [billingBlock, ...systemBlocks];
+}
+
+/**
+ * Splits assistant messages that interleave text and tool_use blocks.
+ *
+ * The Anthropic API rejects assistant turns where non-tool_use blocks follow
+ * a tool_use block.  Pi's serializer can produce this ordering, so we split
+ * the message into two consecutive assistant turns: one with text blocks and
+ * one with tool_use blocks.  The reordering is safe because the text and
+ * tool_use blocks are semantically independent within a single turn.
+ */
+function splitAssistantToolUseTrailingContent(
+  messages: MessageParam[],
+): MessageParam[] {
+  return messages.flatMap((message) => {
+    if (message.role !== "assistant" || !Array.isArray(message.content)) {
+      return [message];
+    }
+
+    const firstToolUseIndex = message.content.findIndex(
+      (block) => block.type === "tool_use",
+    );
+    if (firstToolUseIndex === -1) {
+      return [message];
+    }
+
+    const trailingBlocks = message.content.slice(firstToolUseIndex);
+    if (!trailingBlocks.some((block) => block.type !== "tool_use")) {
+      return [message];
+    }
+
+    const nonToolUseBlocks = message.content.filter(
+      (block) => block.type !== "tool_use",
+    );
+    const toolUseBlocks = message.content.filter(
+      (block) => block.type === "tool_use",
+    );
+
+    return [
+      { ...message, content: nonToolUseBlocks },
+      { ...message, content: toolUseBlocks },
+    ];
+  });
+}
+
+function getToolDefinitionNames(payload: AnthropicPayload): string[] {
+  const tools = payload.tools;
+  if (!Array.isArray(tools)) {
+    return [];
+  }
+
+  return tools
+    .map((tool) =>
+      isRecord(tool) && typeof tool.name === "string" ? tool.name : undefined,
+    )
+    .filter((name): name is string => typeof name === "string");
+}
+
+function getToolUseNames(messages: MessageParam[]): string[] {
+  return messages.flatMap((message) => {
+    if (!Array.isArray(message.content)) {
+      return [];
+    }
+
+    return message.content
+      .map((block) =>
+        block.type === "tool_use" && typeof block.name === "string"
+          ? block.name
+          : undefined,
+      )
+      .filter((name): name is string => typeof name === "string");
+  });
+}
+
+function countAssistantMessages(messages: MessageParam[]): number {
+  return messages.filter((message) => message.role === "assistant").length;
+}
+
+function shouldLogRequestDebug(messages: MessageParam[]): boolean {
+  if (!isToolUseOnlyDebugEnabled()) {
+    return true;
+  }
+
+  return getToolUseNames(messages).length > 0;
+}
+
+export function shapeAnthropicOAuthPayload(payload: unknown): unknown {
+  if (!isAnthropicMessagesPayload(payload)) {
+    return payload;
+  }
+
+  const messages = payload.messages as MessageParam[];
+  if (!isOAuthAnthropicPayload(payload)) {
+    return payload;
+  }
+
+  const normalizedMessages = splitAssistantToolUseTrailingContent(messages);
+
+  const shapedSystem = Array.isArray(payload.system)
+    ? shapeSystemBlocks(payload.system as TextBlock[])
+    : payload.system;
+  const finalSystem = prependBillingHeader(shapedSystem, normalizedMessages);
+
+  const toolUseNamesBefore = getToolUseNames(messages);
+  const toolUseNamesAfter = getToolUseNames(normalizedMessages);
+
+  if (shouldLogRequestDebug(messages)) {
+    debugLog("before-provider-request", {
+      model: payload.model,
+      systemBlockCountBefore: Array.isArray(payload.system)
+        ? payload.system.length
+        : 0,
+      systemBlockCountAfter: Array.isArray(finalSystem)
+        ? finalSystem.length
+        : 0,
+      assistantMessagesBefore: countAssistantMessages(messages),
+      assistantMessagesAfter: countAssistantMessages(normalizedMessages),
+      toolDefinitions: getToolDefinitionNames(payload),
+      toolUseNamesBefore,
+      toolUseNamesAfter,
+    });
+  }
+
+  return {
+    ...payload,
+    messages: normalizedMessages,
+    system: finalSystem,
+  };
+}

package/src/system-prompt-shaping.ts

@@ -0,0 +1,205 @@
+import {
+  MINIMAL_ANTHROPIC_OAUTH_PROMPT,
+  PARAGRAPH_REMOVAL_ANCHORS,
+  PI_DEFAULT_PROMPT_PREFIX,
+  PI_DEFAULT_PROMPT_TERMINATOR,
+  TEXT_REPLACEMENTS,
+} from "./constants";
+import { debugLog, isToolUseOnlyDebugEnabled } from "./debug";
+
+let warnedTerminatorMissing = false;
+
+function warnTerminatorMissingOnce(): void {
+  if (warnedTerminatorMissing) {
+    return;
+  }
+  warnedTerminatorMissing = true;
+  console.warn(
+    "[pi-anthropic-auth] Pi default preamble terminator not found; falling back to '# Project Context' anchor. " +
+      "Upstream Pi may have reworded its preamble — update PI_DEFAULT_PROMPT_TERMINATOR.",
+  );
+}
+
+/**
+ * Reset the one-time terminator-missing warning latch. Exposed for tests.
+ */
+export function _resetShapingWarnings(): void {
+  warnedTerminatorMissing = false;
+}
+
+export type SanitizedSystemTextReport = {
+  text: string;
+  removedParagraphs: Array<{
+    anchor: string;
+    preview: string;
+  }>;
+  replacementMatches: string[];
+};
+
+function previewParagraph(paragraph: string): string {
+  return paragraph.replace(/\s+/g, " ").trim().slice(0, 140);
+}
+
+function shouldLogPromptDebug(report: SanitizedSystemTextReport): boolean {
+  if (!isToolUseOnlyDebugEnabled()) {
+    return true;
+  }
+
+  return (
+    report.removedParagraphs.length === 0 &&
+    report.replacementMatches.length > 0
+  );
+}
+
+/**
+ * Sanitize system prompt text by removing paragraphs containing known
+ * Pi-specific anchor strings and applying inline text replacements for
+ * known Anthropic classifier trigger phrases.
+ *
+ * A paragraph is any text between blank lines (`\n\n`).
+ *
+ * This approach is resilient to upstream rewording — as long as the anchor
+ * string still appears somewhere in the paragraph, removal works regardless
+ * of how the surrounding text changes.
+ */
+export function sanitizeSystemTextWithReport(
+  text: string,
+): SanitizedSystemTextReport {
+  const paragraphs = text.split(/\n\n+/);
+  const removedParagraphs: SanitizedSystemTextReport["removedParagraphs"] = [];
+
+  const filtered = paragraphs.filter((paragraph) => {
+    for (const anchor of PARAGRAPH_REMOVAL_ANCHORS) {
+      if (!paragraph.includes(anchor)) {
+        continue;
+      }
+
+      removedParagraphs.push({
+        anchor,
+        preview: previewParagraph(paragraph),
+      });
+      return false;
+    }
+    return true;
+  });
+
+  let result = filtered.join("\n\n");
+  const replacementMatches: string[] = [];
+
+  for (const rule of TEXT_REPLACEMENTS) {
+    if (result.includes(rule.match)) {
+      replacementMatches.push(rule.match);
+    }
+    result = result.replaceAll(rule.match, rule.replacement);
+  }
+
+  return {
+    text: result.trim(),
+    removedParagraphs,
+    replacementMatches,
+  };
+}
+
+export function sanitizeSystemText(text: string): string {
+  return sanitizeSystemTextWithReport(text).text;
+}
+
+function findProjectContextStart(systemPrompt: string): number {
+  const marker = "\n\n# Project Context\n\n";
+  return systemPrompt.indexOf(marker);
+}
+
+/**
+ * Shape a system prompt string for Anthropic OAuth compatibility.
+ *
+ * For the normal upstream Pi prompt shape, sanitize only the known preamble
+ * span and replace its identity paragraph with the minimal neutral prompt.
+ * This preserves downstream configuration/extension points embedded in the
+ * preamble (tool snippets and guideline bullets) while still stripping the
+ * Pi-specific identity, filler, and documentation paragraphs.
+ *
+ * If Pi's known preamble terminator drifts upstream, we fall back to slicing
+ * from `# Project Context`. If that section is also absent, we return the
+ * minimal prompt only.
+ */
+export function shapeAnthropicOAuthSystemPrompt(systemPrompt: string): string {
+  const prefixIdx = systemPrompt.indexOf(PI_DEFAULT_PROMPT_PREFIX);
+  if (prefixIdx === -1) {
+    return systemPrompt;
+  }
+
+  const terminatorIdx = systemPrompt.indexOf(
+    PI_DEFAULT_PROMPT_TERMINATOR,
+    prefixIdx,
+  );
+  if (terminatorIdx !== -1) {
+    const terminatorEnd = terminatorIdx + PI_DEFAULT_PROMPT_TERMINATOR.length;
+    const preamble = systemPrompt.slice(prefixIdx, terminatorEnd);
+    const report = sanitizeSystemTextWithReport(preamble);
+    const shapedPreamble = report.text
+      ? `${MINIMAL_ANTHROPIC_OAUTH_PROMPT}\n\n${report.text}`
+      : MINIMAL_ANTHROPIC_OAUTH_PROMPT;
+
+    if (shouldLogPromptDebug(report)) {
+      debugLog("system-prompt-shaping", {
+        mode: "terminator",
+        originalLength: systemPrompt.length,
+        preambleLength: preamble.length,
+        sanitizedPreambleLength: report.text.length,
+        removedParagraphCount: report.removedParagraphs.length,
+        removedAnchors: report.removedParagraphs.map((entry) => entry.anchor),
+        removedParagraphPreviews: report.removedParagraphs.map(
+          (entry) => entry.preview,
+        ),
+        replacementMatches: report.replacementMatches,
+      });
+    }
+
+    return (
+      systemPrompt.slice(0, prefixIdx) +
+      shapedPreamble +
+      systemPrompt.slice(terminatorEnd)
+    );
+  }
+
+  warnTerminatorMissingOnce();
+  if (!isToolUseOnlyDebugEnabled()) {
+    debugLog("system-prompt-shaping", {
+      mode: "project-context-fallback",
+      originalLength: systemPrompt.length,
+    });
+  }
+
+  const projectContextStart = findProjectContextStart(systemPrompt);
+  if (projectContextStart === -1) {
+    return MINIMAL_ANTHROPIC_OAUTH_PROMPT;
+  }
+
+  return `${MINIMAL_ANTHROPIC_OAUTH_PROMPT}${systemPrompt.slice(projectContextStart)}`;
+}
+
+type TextBlock = {
+  type: "text";
+  text: string;
+  [key: string]: unknown;
+};
+
+/**
+ * Apply system prompt shaping to an array of Anthropic system text blocks.
+ *
+ * Finds the first block containing Pi's default prompt preamble and replaces
+ * its text in-place (returning a new array).  Blocks without the preamble are
+ * passed through unchanged.
+ */
+export function shapeSystemBlocks(blocks: TextBlock[]): TextBlock[] {
+  return blocks.map((block) => {
+    if (
+      // eslint-disable-next-line @typescript-eslint/no-unnecessary-condition -- defensive runtime guard
+      block.type !== "text" ||
+      !block.text.includes(PI_DEFAULT_PROMPT_PREFIX)
+    ) {
+      return block;
+    }
+    return { ...block, text: shapeAnthropicOAuthSystemPrompt(block.text) };
+  });
+}

package/dist/anthropic-oauth.d.ts

@@ -1,8 +0,0 @@
-import type { OAuthCredentials, OAuthLoginCallbacks } from "@earendil-works/pi-ai";
-export declare function mergeRefreshedCredentials(credentials: OAuthCredentials, refreshed: Partial<OAuthCredentials>): OAuthCredentials;
-export declare const anthropicOAuthOverride: {
-    readonly name: "Anthropic (Claude Pro/Max)";
-    readonly login: (callbacks: OAuthLoginCallbacks) => Promise<OAuthCredentials>;
-    readonly refreshToken: (credentials: OAuthCredentials) => Promise<OAuthCredentials>;
-    readonly getApiKey: (credentials: OAuthCredentials) => string;
-};

package/dist/anthropic-oauth.js

@@ -1,24 +0,0 @@
-import { loginAnthropic, refreshAnthropicToken, } from "@earendil-works/pi-ai/oauth";
-export function mergeRefreshedCredentials(credentials, refreshed) {
-    return {
-        ...credentials,
-        ...refreshed,
-        refresh: typeof refreshed.refresh === "string" &&
-            refreshed.refresh.trim().length > 0
-            ? refreshed.refresh
-            : credentials.refresh,
-    };
-}
-export const anthropicOAuthOverride = {
-    name: "Anthropic (Claude Pro/Max)",
-    login(callbacks) {
-        return loginAnthropic(callbacks);
-    },
-    async refreshToken(credentials) {
-        const refreshed = await refreshAnthropicToken(credentials.refresh);
-        return mergeRefreshedCredentials(credentials, refreshed);
-    },
-    getApiKey(credentials) {
-        return credentials.access;
-    },
-};

package/dist/constants.d.ts

@@ -1,78 +0,0 @@
-/**
- * Prefix of Pi's built-in default system prompt preamble.
- *
- * Used to detect whether a system block contains Pi's original verbose
- * preamble so it can be replaced with the minimal neutral prompt.
- */
-export declare const PI_DEFAULT_PROMPT_PREFIX = "You are an expert coding assistant operating inside pi, a coding agent harness.";
-/**
- * Final line of Pi's built-in default system prompt preamble.
- *
- * Used to replace the entire Pi-generated preamble body with the minimal
- * neutral Anthropic OAuth prompt while preserving anything appended after the
- * preamble (project context, skills, and date/cwd footer).
- */
-export declare const PI_DEFAULT_PROMPT_TERMINATOR = "- Always read pi .md files completely and follow links to related docs (e.g., tui.md for TUI API details)";
-/**
- * Prefix of the minimal neutral Anthropic OAuth system prompt.
- *
- * Used as a detection marker in request shaping to identify system blocks
- * that have already been shaped.  Must match the first line of
- * MINIMAL_ANTHROPIC_OAUTH_PROMPT.
- */
-export declare const MINIMAL_ANTHROPIC_OAUTH_PROMPT_PREFIX = "You are an expert coding assistant.";
-/**
- * Minimal neutral system prompt used for Anthropic OAuth requests.
- *
- * Replaces Pi's verbose default preamble to avoid prompt fingerprinting
- * while preserving any project context that follows.
- */
-export declare const MINIMAL_ANTHROPIC_OAUTH_PROMPT: string;
-/**
- * Prefix of Claude Code's identity injection block.
- *
- * Used to detect OAuth Anthropic payloads built by Pi's built-in Anthropic
- * provider, which injects a "You are Claude Code, Anthropic's official CLI"
- * system block for OAuth sessions.
- */
-export declare const CLAUDE_CODE_IDENTITY_PREFIX = "You are Claude Code, Anthropic's official CLI";
-/**
- * Claude Code version string embedded in the billing header.
- *
- * **Must be kept in sync with the current Claude Code release.**
- * Update this value when a new Claude Code version ships.  If it drifts
- * too far from what Anthropic expects, OAuth requests may be rejected or
- * counted incorrectly.
- */
-export declare const CLAUDE_CODE_VERSION = "2.1.119";
-/** Salt used in the billing header suffix hash. */
-export declare const BILLING_HEADER_SALT = "59cf53e54c78";
-/** Character positions sampled from the first user message for the billing hash. */
-export declare const BILLING_HEADER_POSITIONS: readonly [4, 7, 20];
-/** Entrypoint identifier included in the billing header. */
-export declare const CLAUDE_CODE_ENTRYPOINT = "sdk-cli";
-/**
- * Strings whose presence in a paragraph marks it as Pi-specific and droppable.
- *
- * Each entry is checked with `paragraph.includes(anchor)`.
- */
-export declare const PARAGRAPH_REMOVAL_ANCHORS: readonly string[];
-/**
- * Inline text replacements applied after paragraph removal.
- *
- * These handle known Anthropic classifier trigger phrases that may appear
- * in paragraphs we want to keep.  Each rule is applied with `replaceAll`.
- *
- * The "Here is some useful information..." phrase was isolated by
- * `opencode-anthropic-auth` via sliding-window bisection of a 10KB failing
- * prompt.  When it reaches Anthropic combined with typical agent context,
- * /v1/messages responds with a 400 disguised as "You're out of extra usage."
- * Replacing the word "useful" is enough to unblock the request.
- *
- * We don't currently emit this phrase, but it's included as a documented
- * future risk per Issue #10.
- */
-export declare const TEXT_REPLACEMENTS: readonly {
-    match: string;
-    replacement: string;
-}[];

package/dist/debug.d.ts

@@ -1,3 +0,0 @@
-export declare function isDebugEnabled(): boolean;
-export declare function isToolUseOnlyDebugEnabled(): boolean;
-export declare function debugLog(scope: string, data: unknown): void;

package/dist/debug.js

@@ -1,32 +0,0 @@
-function getDebugMode(value) {
-    if (!value)
-        return "off";
-    switch (value.trim().toLowerCase()) {
-        case "1":
-        case "true":
-        case "yes":
-        case "on":
-        case "debug":
-        case "all":
-            return "all";
-        case "tool":
-        case "tools":
-        case "tool-use":
-        case "tool_use":
-            return "tool-use";
-        default:
-            return "off";
-    }
-}
-export function isDebugEnabled() {
-    return getDebugMode(process.env.PI_ANTHROPIC_AUTH_DEBUG) !== "off";
-}
-export function isToolUseOnlyDebugEnabled() {
-    return getDebugMode(process.env.PI_ANTHROPIC_AUTH_DEBUG) === "tool-use";
-}
-export function debugLog(scope, data) {
-    if (!isDebugEnabled()) {
-        return;
-    }
-    console.error(`[pi-anthropic-auth][debug] ${scope} ${JSON.stringify(data)}`);
-}

package/dist/index.d.ts

@@ -1,2 +0,0 @@
-import type { ExtensionAPI } from "@earendil-works/pi-coding-agent";
-export default function (pi: ExtensionAPI): void;

package/dist/index.js

@@ -1,10 +0,0 @@
-import { anthropicOAuthOverride } from "./anthropic-oauth.js";
-import { shapeAnthropicOAuthPayload } from "./request-shaping.js";
-export default function (pi) {
-    pi.registerProvider("anthropic", {
-        oauth: anthropicOAuthOverride,
-    });
-    pi.on("before_provider_request", (event) => {
-        return shapeAnthropicOAuthPayload(event.payload);
-    });
-}

package/dist/request-shaping.d.ts

@@ -1 +0,0 @@
-export declare function shapeAnthropicOAuthPayload(payload: unknown): unknown;