@centerforagenticai/pi-multi-account 0.1.1

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

@@ -0,0 +1,476 @@
+import Anthropic from "@anthropic-ai/sdk";
+import type { MessageCreateParamsStreaming } from "@anthropic-ai/sdk/resources/messages.js";
+import {
+  type Api,
+  type AssistantMessage,
+  type AssistantMessageEventStream,
+  calculateCost,
+  type Context,
+  createAssistantMessageEventStream,
+  type Model,
+  type SimpleStreamOptions,
+  type StopReason,
+} from "@earendil-works/pi-ai";
+import { isClaudeOAuthAccessToken, USER_AGENT } from "./auth.js";
+import {
+  convertPiMessagesToAnthropic,
+  convertPiToolsToAnthropic,
+  fromClaudeCodeToolName,
+  type IndexedBlock,
+} from "./convert.js";
+import { projectContext } from "./context.js";
+import { buildAnthropicSystemPrompt } from "./prompt.js";
+
+const REQUIRED_BETAS = [
+  "claude-code-20250219",
+  "oauth-2025-04-20",
+  // fine-grained-tool-streaming removed: it ships the model's raw, unvalidated
+  // tool-input JSON. For large edits full of quotes/newlines the streamed
+  // string escaping breaks, so a field (e.g. edit.oldText) swallows the rest of
+  // the structure — surfacing as either a hard JSON.parse crash or a wrong-shape
+  // schema-validation failure. Default streaming has the server validate/buffer
+  // tool JSON, guaranteeing well-formed, correctly-structured input.
+  "interleaved-thinking-2025-05-14",
+] as const;
+
+function mapStopReason(reason: string | null | undefined): StopReason {
+  switch (reason) {
+    case "end_turn":
+    case "pause_turn":
+    case "stop_sequence":
+      return "stop";
+    case "max_tokens":
+      return "length";
+    case "tool_use":
+      return "toolUse";
+    default:
+      return "error";
+  }
+}
+
+function headersToRecord(headers: Headers): Record<string, string> {
+  const record: Record<string, string> = {};
+  headers.forEach((value, key) => {
+    record[key] = value;
+  });
+  return record;
+}
+
+function makeDefaultHeaders(
+  isOAuth: boolean,
+  options?: SimpleStreamOptions,
+): Record<string, string> {
+  const headers: Record<string, string> = {
+    accept: "application/json",
+    "anthropic-dangerous-direct-browser-access": "true",
+  };
+
+  if (isOAuth) {
+    headers["anthropic-beta"] = REQUIRED_BETAS.join(",");
+    headers["user-agent"] = USER_AGENT;
+    headers["x-app"] = "cli";
+  } else {
+    headers["anthropic-beta"] = ["interleaved-thinking-2025-05-14"].join(",");
+  }
+
+  if (options?.headers) {
+    for (const [key, value] of Object.entries(options.headers)) {
+      const normalizedKey = key.toLowerCase();
+      if (
+        isOAuth &&
+        (normalizedKey === "x-api-key" || normalizedKey === "authorization")
+      ) {
+        continue;
+      }
+      const existingKey = Object.keys(headers).find(
+        (header) => header.toLowerCase() === normalizedKey,
+      );
+      if (existingKey) delete headers[existingKey];
+      if (value !== null) headers[key] = value;
+    }
+  }
+
+  return headers;
+}
+
+export function streamAnthropicOAuth(
+  model: Model<Api>,
+  context: Context,
+  options?: SimpleStreamOptions,
+): AssistantMessageEventStream {
+  const stream = createAssistantMessageEventStream();
+
+  void (async () => {
+    const output: AssistantMessage = {
+      role: "assistant",
+      content: [],
+      api: model.api,
+      provider: model.provider,
+      model: model.id,
+      usage: {
+        input: 0,
+        output: 0,
+        cacheRead: 0,
+        cacheWrite: 0,
+        totalTokens: 0,
+        cost: { input: 0, output: 0, cacheRead: 0, cacheWrite: 0, total: 0 },
+      },
+      stopReason: "stop",
+      timestamp: Date.now(),
+    };
+
+    try {
+      const apiKey = options?.apiKey;
+      if (!apiKey) {
+        throw new Error(
+          "No Anthropic auth available. Run /login and choose Claude Pro/Max.",
+        );
+      }
+
+      const isOAuth = isClaudeOAuthAccessToken(apiKey);
+      const defaultHeaders = makeDefaultHeaders(isOAuth, options);
+
+      if (isOAuth) defaultHeaders.authorization = `Bearer ${apiKey}`;
+
+      const client = new Anthropic({
+        baseURL: model.baseUrl,
+        apiKey: isOAuth ? null : apiKey,
+        authToken: isOAuth ? apiKey : null,
+        defaultHeaders,
+        dangerouslyAllowBrowser: true,
+      });
+
+      const maxTokens =
+        options?.maxTokens || Math.floor(model.maxTokens / 3);
+      const projectedContext = projectContext(context);
+
+      const params: MessageCreateParamsStreaming = {
+        model: model.id,
+        messages: convertPiMessagesToAnthropic(
+          projectedContext.messages,
+          isOAuth,
+          model,
+        ),
+        max_tokens: maxTokens,
+        stream: true,
+      };
+
+      const system = buildAnthropicSystemPrompt(
+        projectedContext.systemPrompt,
+        isOAuth,
+      );
+      if (system) params.system = system as never;
+      if (projectedContext.tools.length) {
+        params.tools = convertPiToolsToAnthropic(
+          projectedContext.tools,
+          isOAuth,
+        );
+      }
+      if (options?.reasoning && model.reasoning && maxTokens > 1) {
+        const defaultBudgets: Record<string, number> = {
+          minimal: 1024,
+          low: 4096,
+          medium: 10240,
+          high: 20480,
+          xhigh: 32000,
+        };
+        const customBudget =
+          options.thinkingBudgets?.[
+            options.reasoning as keyof typeof options.thinkingBudgets
+          ];
+        const requestedBudget =
+          customBudget ?? defaultBudgets[options.reasoning] ?? 10240;
+        const display = "summarized";
+        const forceAdaptive = (
+          model.compat as { forceAdaptiveThinking?: boolean } | undefined
+        )?.forceAdaptiveThinking;
+        const id = model.id.toLowerCase().replace(/\./g, "-");
+        const adaptive =
+          forceAdaptive === true ||
+          (forceAdaptive !== false &&
+            (/claude-(?:opus|sonnet|haiku|fable|mythos)-5(?:-|$)/.test(id) ||
+              /claude-(?:opus|sonnet|haiku|fable|mythos)-4-(?:[6-9]|\d{2,})(?:-|$)/.test(
+                id,
+              )));
+
+        if (adaptive) {
+          const mapped = model.thinkingLevelMap?.[options.reasoning];
+          const effort =
+            typeof mapped === "string"
+              ? mapped
+              : options.reasoning === "minimal" || options.reasoning === "low"
+                ? "low"
+                : options.reasoning === "medium"
+                  ? "medium"
+                  : options.reasoning === "high"
+                    ? "high"
+                    : "high";
+          params.thinking = { type: "adaptive", display } as never;
+          Object.assign(params, { output_config: { effort } });
+        } else {
+          params.thinking = {
+            type: "enabled",
+            budget_tokens: Math.min(requestedBudget, maxTokens - 1),
+            display,
+          } as never;
+        }
+      }
+
+      // Raw stream instead of the MessageStream helper: MessageStream
+      // accumulates tool_use input and JSON.parses it on content_block_stop,
+      // which throws under fine-grained-tool-streaming (input may be invalid
+      // mid-flight) and aborts the turn. The raw stream yields the same
+      // RawMessageStreamEvents; tool args are already parsed leniently below.
+      const { data: anthropicStream, response: httpResponse } =
+        await client.messages
+          .create(params, {
+            signal: options?.signal,
+          })
+          .withResponse();
+
+      if (options?.onResponse) {
+        try {
+          await options.onResponse(
+            {
+              status: httpResponse.status,
+              headers: headersToRecord(httpResponse.headers),
+            },
+            model,
+          );
+        } catch {
+          // Response hooks are best-effort and should not break streaming.
+        }
+      }
+
+      stream.push({ type: "start", partial: output });
+
+      const blocks = output.content as IndexedBlock[];
+
+      for await (const event of anthropicStream) {
+        if (event.type === "message_start") {
+          output.usage.input = event.message.usage.input_tokens || 0;
+          output.usage.output = event.message.usage.output_tokens || 0;
+          output.usage.cacheRead =
+            (event.message.usage as { cache_read_input_tokens?: number })
+              .cache_read_input_tokens || 0;
+          output.usage.cacheWrite =
+            (event.message.usage as { cache_creation_input_tokens?: number })
+              .cache_creation_input_tokens || 0;
+          output.usage.totalTokens =
+            output.usage.input +
+            output.usage.output +
+            output.usage.cacheRead +
+            output.usage.cacheWrite;
+          calculateCost(model, output.usage);
+          continue;
+        }
+
+        if (event.type === "content_block_start") {
+          if (event.content_block.type === "text") {
+            output.content.push({
+              type: "text",
+              text: "",
+              index: event.index,
+            } as IndexedBlock);
+            stream.push({
+              type: "text_start",
+              contentIndex: output.content.length - 1,
+              partial: output,
+            });
+          } else if (event.content_block.type === "thinking") {
+            output.content.push({
+              type: "thinking",
+              thinking: "",
+              thinkingSignature: "",
+              index: event.index,
+            } as IndexedBlock);
+            stream.push({
+              type: "thinking_start",
+              contentIndex: output.content.length - 1,
+              partial: output,
+            });
+          } else if (event.content_block.type === "redacted_thinking") {
+            output.content.push({
+              type: "thinking",
+              thinking: "[Reasoning redacted]",
+              thinkingSignature: event.content_block.data,
+              redacted: true,
+              index: event.index,
+            } as IndexedBlock);
+            stream.push({
+              type: "thinking_start",
+              contentIndex: output.content.length - 1,
+              partial: output,
+            });
+          } else if (event.content_block.type === "tool_use") {
+            output.content.push({
+              type: "toolCall",
+              id: event.content_block.id,
+              name: isOAuth
+                ? fromClaudeCodeToolName(
+                    event.content_block.name,
+                    projectedContext.tools,
+                  )
+                : event.content_block.name,
+              arguments: {},
+              partialJson: "",
+              index: event.index,
+            } as IndexedBlock);
+            stream.push({
+              type: "toolcall_start",
+              contentIndex: output.content.length - 1,
+              partial: output,
+            });
+          }
+          continue;
+        }
+
+        if (event.type === "content_block_delta") {
+          const contentIndex = blocks.findIndex(
+            (block) => block.index === event.index,
+          );
+          const block = blocks[contentIndex];
+          if (!block) continue;
+
+          if (event.delta.type === "text_delta" && block.type === "text") {
+            block.text += event.delta.text;
+            stream.push({
+              type: "text_delta",
+              contentIndex,
+              delta: event.delta.text,
+              partial: output,
+            });
+          } else if (
+            event.delta.type === "thinking_delta" &&
+            block.type === "thinking"
+          ) {
+            block.thinking += event.delta.thinking;
+            stream.push({
+              type: "thinking_delta",
+              contentIndex,
+              delta: event.delta.thinking,
+              partial: output,
+            });
+          } else if (
+            event.delta.type === "signature_delta" &&
+            block.type === "thinking"
+          ) {
+            block.thinkingSignature =
+              (block.thinkingSignature || "") + event.delta.signature;
+          } else if (
+            event.delta.type === "input_json_delta" &&
+            block.type === "toolCall"
+          ) {
+            block.partialJson += event.delta.partial_json;
+            try {
+              block.arguments = JSON.parse(block.partialJson) as Record<
+                string,
+                unknown
+              >;
+            } catch {}
+            stream.push({
+              type: "toolcall_delta",
+              contentIndex,
+              delta: event.delta.partial_json,
+              partial: output,
+            });
+          }
+          continue;
+        }
+
+        if (event.type === "content_block_stop") {
+          const contentIndex = blocks.findIndex(
+            (block) => block.index === event.index,
+          );
+          const block = blocks[contentIndex];
+          if (!block) continue;
+
+          delete (block as { index?: number }).index;
+          if (block.type === "text") {
+            stream.push({
+              type: "text_end",
+              contentIndex,
+              content: block.text,
+              partial: output,
+            });
+          } else if (block.type === "thinking") {
+            stream.push({
+              type: "thinking_end",
+              contentIndex,
+              content: block.thinking,
+              partial: output,
+            });
+          } else if (block.type === "toolCall") {
+            try {
+              block.arguments = JSON.parse(block.partialJson) as Record<
+                string,
+                unknown
+              >;
+            } catch {}
+            delete (block as { partialJson?: string }).partialJson;
+            stream.push({
+              type: "toolcall_end",
+              contentIndex,
+              toolCall: block,
+              partial: output,
+            });
+          }
+          continue;
+        }
+
+        if (event.type === "message_delta") {
+          output.stopReason = mapStopReason(event.delta.stop_reason);
+          output.usage.input =
+            (event.usage as { input_tokens?: number }).input_tokens ||
+            output.usage.input;
+          output.usage.output =
+            (event.usage as { output_tokens?: number }).output_tokens ||
+            output.usage.output;
+          output.usage.cacheRead =
+            (event.usage as { cache_read_input_tokens?: number })
+              .cache_read_input_tokens || 0;
+          output.usage.cacheWrite =
+            (event.usage as { cache_creation_input_tokens?: number })
+              .cache_creation_input_tokens || 0;
+          const thinkingTokens = (
+            event.usage as {
+              output_tokens_details?: { thinking_tokens?: number };
+            }
+          ).output_tokens_details?.thinking_tokens;
+          if (thinkingTokens != null) {
+            output.usage.reasoning = thinkingTokens;
+          }
+          output.usage.totalTokens =
+            output.usage.input +
+            output.usage.output +
+            output.usage.cacheRead +
+            output.usage.cacheWrite;
+          calculateCost(model, output.usage);
+        }
+      }
+
+      if (options?.signal?.aborted) throw new Error("Request aborted");
+      stream.push({
+        type: "done",
+        reason: output.stopReason as "stop" | "length" | "toolUse",
+        message: output,
+      });
+      stream.end();
+    } catch (error) {
+      for (const block of output.content as Array<{
+        index?: number;
+        partialJson?: string;
+      }>) {
+        delete block.index;
+        delete block.partialJson;
+      }
+      output.stopReason = options?.signal?.aborted ? "aborted" : "error";
+      output.errorMessage =
+        error instanceof Error ? error.message : String(error);
+      stream.push({ type: "error", reason: output.stopReason, error: output });
+      stream.end();
+    }
+  })();
+
+  return stream;
+}

package/packages/pi-antigravity/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Rahul Arya
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/packages/pi-antigravity/package.json

@@ -0,0 +1,77 @@
+{
+  "name": "pi-antigravity",
+  "version": "0.7.2-intel.1",
+  "description": "Personal Antigravity / Cloud Code Assist provider for Pi Coding Agent",
+  "author": "Rahul Arya",
+  "license": "MIT",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/Rahularya01/pi-antigravity.git"
+  },
+  "homepage": "https://github.com/Rahularya01/pi-antigravity#readme",
+  "bugs": {
+    "url": "https://github.com/Rahularya01/pi-antigravity/issues"
+  },
+  "type": "module",
+  "main": "./src/index.ts",
+  "keywords": [
+    "pi-package",
+    "pi-extension",
+    "antigravity",
+    "google",
+    "oauth",
+    "provider"
+  ],
+  "files": [
+    "LICENSE",
+    "README.md",
+    "UPSTREAM.json",
+    "src",
+    "tsconfig.json",
+    "UPSTREAM.md",
+    "SOURCE_MANIFEST.sha256"
+  ],
+  "packageManager": "bun@1.4.0",
+  "scripts": {
+    "build": "tsc -p tsconfig.json --noEmit",
+    "prepare": "npm run build",
+    "typecheck": "tsc --noEmit",
+    "lint": "eslint src",
+    "lint:fix": "eslint src --fix",
+    "format": "prettier --write .",
+    "format:check": "prettier --check .",
+    "security-check": "bun scripts/security-check.ts",
+    "test": "bun scripts/test-model-routing.ts && bun scripts/test-model-discovery.ts && bun scripts/test-usage-formatter.ts && bun scripts/test-stream-sse.ts && bun scripts/test-stream-header-deadline.ts && bun scripts/test-http-proxy.ts && bun scripts/test-image-gen.ts && bun run test:stream-primary-error && bun run test:usage-abort && bun run test:context-projection",
+    "test:stream-primary-error": "bun scripts/test-stream-primary-error.ts",
+    "test:usage-abort": "bun scripts/test-usage-abort.ts",
+    "smoke:tools": "bun scripts/smoke-tool-schema.ts",
+    "smoke:models": "bun scripts/smoke-all-models.mjs",
+    "check": "bun run typecheck && bun run lint && bun run format:check && bun run security-check && bun run test",
+    "test:context-projection": "bun scripts/test-context-projection.ts",
+    "test:context-projection:normalized": "bun scripts/test-context-projection.ts normalized"
+  },
+  "pi": {
+    "extensions": [
+      "./src/index.ts"
+    ]
+  },
+  "peerDependencies": {
+    "@earendil-works/pi-ai": ">=0.80.0",
+    "@earendil-works/pi-coding-agent": ">=0.80.0"
+  },
+  "devDependencies": {
+    "@earendil-works/pi-ai": "^0.84.2",
+    "@eslint/js": "^10.0.1",
+    "@types/node": "^26.1.1",
+    "eslint": "^10.7.0",
+    "eslint-config-prettier": "^10.1.8",
+    "globals": "^17.7.0",
+    "pi-ai-087": "npm:@earendil-works/pi-ai@0.87.1",
+    "prettier": "^3.9.5",
+    "typescript": "^6.0.3",
+    "typescript-eslint": "^8.64.0"
+  },
+  "dependencies": {
+    "undici": "^8.10.0"
+  }
+}

package/packages/pi-antigravity/src/auth/index.ts

@@ -0,0 +1,14 @@
+export {
+  loginAntigravity,
+  refreshAntigravityToken,
+  getApiKey,
+  CLIENT_ID,
+  CLIENT_SECRET,
+  REDIRECT_URI,
+  AUTH_URL,
+  TOKEN_URL,
+  SCOPES,
+  CALLBACK_HOST,
+  OAUTH_CALLBACK_TIMEOUT_MS,
+} from "./oauth.js";
+export type { OAuthCredentials, OAuthLoginCallbacks } from "./oauth.js";