@centerforagenticai/pi-multi-account 0.1.1

package/packages/pi-anthropic-oauth/src/convert.ts

@@ -0,0 +1,303 @@
+import type { ContentBlockParam, MessageParam, ToolUnion } from "@anthropic-ai/sdk/resources/messages.js";
+
+type ToolResultContentBlock =
+  | { type: "text"; text: string }
+  | {
+      type: "image";
+      source: {
+        type: "base64";
+        media_type: "image/jpeg" | "image/png" | "image/gif" | "image/webp";
+        data: string;
+      };
+    };
+import type {
+  Api,
+  ImageContent,
+  Message,
+  Model,
+  TextContent,
+  ThinkingContent,
+  Tool,
+  ToolCall,
+  ToolResultMessage,
+} from "@earendil-works/pi-ai";
+import { sanitizeSurrogates } from "./prompt.js";
+
+export type IndexedBlock =
+  | (TextContent & { index: number })
+  | (ThinkingContent & { index: number; thinkingSignature?: string })
+  | (ToolCall & { index: number; partialJson: string });
+
+const claudeCodeTools = [
+  "Read",
+  "Write",
+  "Edit",
+  "Bash",
+  "Grep",
+  "Glob",
+  "AskUserQuestion",
+  "TodoWrite",
+  "WebFetch",
+  "WebSearch",
+] as const;
+const claudeCodeToolLookup = new Map(claudeCodeTools.map((name) => [name.toLowerCase(), name]));
+
+// Anthropic's OAuth classifier rejects tool definitions with names outside
+// Claude Code's own tool set with a 400 "Third-party apps now draw from your
+// extra usage" error. Claude Code exposes MCP tools as `mcp__<server>__<tool>`,
+// so unknown tools are namespaced under `mcp__pi__`.
+const CLAUDE_CODE_MCP_TOOL_PREFIX = "mcp__pi__";
+
+function sanitizeCustomToolName(name: string): string {
+  return name.replace(/[^a-zA-Z0-9_-]/g, "_");
+}
+
+export function toClaudeCodeToolName(name: string): string {
+  return (
+    claudeCodeToolLookup.get(name.toLowerCase()) ??
+    `${CLAUDE_CODE_MCP_TOOL_PREFIX}${sanitizeCustomToolName(name)}`
+  );
+}
+
+export function fromClaudeCodeToolName(name: string, tools?: Tool[]): string {
+  if (name.startsWith(CLAUDE_CODE_MCP_TOOL_PREFIX)) {
+    const stripped = name.slice(CLAUDE_CODE_MCP_TOOL_PREFIX.length);
+    return tools?.find((tool) => sanitizeCustomToolName(tool.name) === stripped)?.name ?? stripped;
+  }
+  const lower = name.toLowerCase();
+  return tools?.find((tool) => tool.name.toLowerCase() === lower)?.name ?? name;
+}
+
+export function convertPiMessagesToAnthropic(
+  messages: Message[],
+  isOAuth: boolean,
+  model: Pick<Model<Api>, "provider" | "api" | "id">,
+): 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;
+  };
+
+  // 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 {
+        const blocks: ContentBlockParam[] = message.content.map((item) =>
+          item.type === "text"
+            ? { type: "text", text: sanitizeSurrogates(item.text) }
+            : {
+                type: "image",
+                source: { type: "base64", media_type: item.mimeType as never, data: item.data },
+              },
+        );
+        if (blocks.length > 0) params.push({ role: "user", content: blocks });
+      }
+      continue;
+    }
+
+    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[] = [];
+      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({
+            type: "tool_use",
+            id: anthropicId,
+            name: isOAuth ? toClaudeCodeToolName(block.name) : block.name,
+            input: block.arguments ?? {},
+          });
+          emittedToolUseIds.push(anthropicId);
+        }
+      }
+      if (blocks.length > 0) {
+        params.push({ role: "assistant", content: blocks });
+        pendingToolUseIds = emittedToolUseIds;
+      }
+      continue;
+    }
+
+    if (message.role === "toolResult") {
+      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",
+          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 });
+    }
+  }
+
+  const last = params.at(-1);
+  if (last?.role === "user" && Array.isArray(last.content) && last.content.length > 0) {
+    const lastBlock = last.content[last.content.length - 1] as { cache_control?: { type: string } };
+    lastBlock.cache_control = { type: "ephemeral" };
+  }
+
+  return params;
+}
+
+export function convertPiToolsToAnthropic(tools: Tool[], isOAuth: boolean): ToolUnion[] {
+  return tools.map((tool) => ({
+    name: isOAuth ? toClaudeCodeToolName(tool.name) : tool.name,
+    description: tool.description,
+    input_schema: {
+      type: "object" as const,
+      properties: (tool.parameters as { properties?: Record<string, unknown> }).properties ?? {},
+      required: (tool.parameters as { required?: string[] }).required ?? [],
+    },
+  }));
+}
+
+function convertToolResultContentToAnthropic(
+  content: (TextContent | ImageContent)[],
+): string | ToolResultContentBlock[] {
+  const hasImages = content.some((block) => block.type === "image");
+  if (!hasImages) {
+    return sanitizeSurrogates(
+      content
+        .filter((block): block is TextContent => block.type === "text")
+        .map((block) => block.text)
+        .join("\n"),
+    );
+  }
+
+  const blocks = content.map((block) => {
+    if (block.type === "text") return { type: "text" as const, text: sanitizeSurrogates(block.text) };
+    return {
+      type: "image" as const,
+      source: {
+        type: "base64" as const,
+        media_type: block.mimeType as ToolResultContentBlock extends { type: "image"; source: infer S }
+          ? S extends { media_type: infer M }
+            ? M
+            : never
+          : never,
+        data: block.data,
+      },
+    };
+  });
+
+  if (!blocks.some((block) => block.type === "text")) {
+    blocks.unshift({ type: "text", text: "(see attached image)" });
+  }
+
+  return blocks;
+}

package/packages/pi-anthropic-oauth/src/index.ts

@@ -0,0 +1,37 @@
+import { existsSync, symlinkSync } from "node:fs";
+import { homedir } from "node:os";
+import { join } from "node:path";
+import {
+  type ExtensionAPI,
+  type ProviderConfig,
+} from "@earendil-works/pi-coding-agent";
+import type { OAuthCredentials } from "@earendil-works/pi-ai";
+import { loginAnthropic, refreshAnthropicToken } from "./auth.js";
+import { streamAnthropicOAuth } from "./stream.js";
+
+function ensureClaudeCodeSymlink() {
+  const target = join(homedir(), ".pi");
+  const link = join(homedir(), ".Claude Code");
+  if (existsSync(target) && !existsSync(link)) {
+    try {
+      symlinkSync(target, link);
+    } catch { }
+  }
+}
+
+export default function (pi: ExtensionAPI) {
+  ensureClaudeCodeSymlink();
+
+  pi.registerProvider("anthropic", {
+    baseUrl: "https://api.anthropic.com",
+    api: "anthropic-messages",
+    oauth: {
+      name: "Claude Pro/Max",
+      usesCallbackServer: true,
+      login: loginAnthropic,
+      refreshToken: refreshAnthropicToken,
+      getApiKey: (credentials: OAuthCredentials) => credentials.access,
+    } as unknown as ProviderConfig["oauth"],
+    streamSimple: streamAnthropicOAuth,
+  });
+}

package/packages/pi-anthropic-oauth/src/prompt.ts

@@ -0,0 +1,137 @@
+const CLAUDE_CODE_IDENTITY =
+  "You are Claude Code, Anthropic's official CLI for Claude.";
+const PI_REMOVAL_ANCHORS = [
+  "pi-coding-agent",
+  "@earendil-works/pi-coding-agent",
+  "badlogic/pi-mono",
+] as const;
+
+export const PI_REWRITE_MODE_ENV = "PI_ANTHROPIC_OAUTH_REWRITE_MODE";
+export const PI_REWRITE_PATTERN_ENV = "PI_ANTHROPIC_OAUTH_REWRITE_PATTERN";
+
+export type PiRewriteMode = "aggressive" | "path-safe" | "technical-safe" | "custom";
+
+const DEFAULT_PI_REWRITE_MODE: PiRewriteMode = "aggressive";
+const PI_REWRITE_PATTERN_SOURCES: Record<Exclude<PiRewriteMode, "custom">, string> = {
+  aggressive: String.raw`\b[Pp]i\b`,
+  "path-safe": String.raw`(?<![/\\])\b[Pp]i\b`,
+  "technical-safe": String.raw`(?<![/\\.@:_-])\b[Pp]i\b(?![/\\.@:_-])`,
+};
+
+const PI_REWRITE_MODES = new Set<PiRewriteMode>([
+  "aggressive",
+  "path-safe",
+  "technical-safe",
+  "custom",
+]);
+
+type MessageContentBlock = {
+  type: string;
+  text?: string;
+  [key: string]: unknown;
+};
+
+export function sanitizeSurrogates(text: string): string {
+  // Replace only *unpaired* surrogates: a high surrogate not followed by a low
+  // surrogate, or a low surrogate not preceded by a high surrogate. Valid
+  // surrogate pairs (non-BMP characters such as emoji) must pass through
+  // untouched. Equivalent to String.prototype.toWellFormed(), which requires
+  // Node 20+ while this package supports Node >=18.
+  return text.replace(
+    /[\uD800-\uDBFF](?![\uDC00-\uDFFF])|(?<![\uD800-\uDBFF])[\uDC00-\uDFFF]/g,
+    "\uFFFD",
+  );
+}
+
+export function buildAnthropicSystemPrompt(
+  systemPrompt: string | undefined,
+  isOAuth: boolean,
+): MessageContentBlock[] | undefined {
+  const blocks: MessageContentBlock[] = [];
+
+  if (isOAuth) {
+    blocks.push({
+      type: "text",
+      text: CLAUDE_CODE_IDENTITY,
+      cache_control: { type: "ephemeral" },
+    });
+  }
+
+  const sanitized = systemPrompt ? sanitizeSystemText(systemPrompt) : "";
+  if (sanitized) {
+    blocks.push({
+      type: "text",
+      text: sanitized,
+      cache_control: { type: "ephemeral" },
+    });
+  }
+
+  return blocks.length > 0 ? blocks : undefined;
+}
+
+export function sanitizeSystemText(
+  text: string,
+  env: NodeJS.ProcessEnv = process.env,
+): string {
+  const paragraphs = text.split(/\n\n+/);
+  const filtered = paragraphs.filter((paragraph) => {
+    const lower = paragraph.toLowerCase();
+    if (lower.includes("you are pi")) return false;
+    return !PI_REMOVAL_ANCHORS.some((anchor) => paragraph.includes(anchor));
+  });
+
+  return filtered
+    .join("\n\n")
+    .replace(resolvePiRewritePattern(env), "Claude Code")
+    .trim();
+}
+
+function resolvePiRewritePattern(env: NodeJS.ProcessEnv): RegExp {
+  const mode = parsePiRewriteMode(env[PI_REWRITE_MODE_ENV]);
+  if (mode === "custom") return compileCustomPiRewritePattern(env[PI_REWRITE_PATTERN_ENV]);
+  return new RegExp(PI_REWRITE_PATTERN_SOURCES[mode], "g");
+}
+
+function parsePiRewriteMode(value: string | undefined): PiRewriteMode {
+  if (!value?.trim()) return DEFAULT_PI_REWRITE_MODE;
+  const mode = value.trim().toLowerCase();
+  if (PI_REWRITE_MODES.has(mode as PiRewriteMode)) return mode as PiRewriteMode;
+  throw new Error(
+    `Invalid ${PI_REWRITE_MODE_ENV}: ${value}. Expected one of ${Array.from(PI_REWRITE_MODES).join(", ")}.`,
+  );
+}
+
+function compileCustomPiRewritePattern(value: string | undefined): RegExp {
+  const pattern = value?.trim();
+  if (!pattern) {
+    throw new Error(`${PI_REWRITE_PATTERN_ENV} must be set when ${PI_REWRITE_MODE_ENV}=custom.`);
+  }
+
+  const parsed = parseRegexLiteral(pattern) ?? { source: pattern, flags: "" };
+  const flags = parsed.flags.includes("g") ? parsed.flags : `${parsed.flags}g`;
+  try {
+    return new RegExp(parsed.source, flags);
+  } catch (error) {
+    const message = error instanceof Error ? error.message : String(error);
+    throw new Error(`Invalid ${PI_REWRITE_PATTERN_ENV}: ${message}`);
+  }
+}
+
+function parseRegexLiteral(value: string): { source: string; flags: string } | undefined {
+  if (!value.startsWith("/")) return undefined;
+
+  for (let index = value.length - 1; index > 0; index--) {
+    if (value[index] !== "/" || isEscaped(value, index)) continue;
+    return { source: value.slice(1, index), flags: value.slice(index + 1) };
+  }
+
+  return undefined;
+}
+
+function isEscaped(value: string, index: number): boolean {
+  let slashCount = 0;
+  for (let cursor = index - 1; cursor >= 0 && value[cursor] === "\\"; cursor--) {
+    slashCount++;
+  }
+  return slashCount % 2 === 1;
+}