@jameslovespancakes/pi-plus 1.0.15 → 1.0.17

package/src/core/gemini/client.ts

@@ -0,0 +1,188 @@
+import { createHash } from "node:crypto";
+
+/**
+ * Gemini's `v1internal` control plane: project discovery, the account
+ * email, and the live model list.
+ *
+ * Plain `fetch`, no pi types, so everything here is unit-testable without a
+ * session. The wire details (endpoints, User-Agent, request bodies) follow
+ * the Antigravity CLI as tracked by `pi-antigravity`; the backend identifies
+ * its callers and refuses ones it does not recognise.
+ */
+
+/** Daily carries rollouts first, so it leads; production is the last resort. */
+export const GEMINI_ENDPOINT = "https://daily-cloudcode-pa.googleapis.com";
+export const GEMINI_ENDPOINTS: readonly string[] = [
+  GEMINI_ENDPOINT,
+  "https://daily-cloudcode-pa.sandbox.googleapis.com",
+  "https://cloudcode-pa.googleapis.com",
+];
+
+export const GEMINI_USER_AGENT =
+  "antigravity/cli/1.1.23 (aidev_client; os_type=linux; arch=amd64; cl=974125021; auth_method=consumer)";
+
+/** Metadata lookups must be quick; a stalled endpoint falls through to the next. */
+const DISCOVERY_TIMEOUT_MS = 8_000;
+
+export function geminiEnv(name: string): string | undefined {
+  const value = process.env[`PI_GEMINI_${name}`]?.trim();
+  return value || undefined;
+}
+
+export function geminiHeaders(token: string): Record<string, string> {
+  return {
+    Authorization: `Bearer ${token}`,
+    "Content-Type": "application/json",
+    "User-Agent": GEMINI_USER_AGENT,
+  };
+}
+
+/**
+ * Endpoints for a request, in order. A base URL the user configured for the
+ * provider (pi's `models.json` override) is used alone; otherwise every
+ * Gemini endpoint is tried.
+ */
+export function endpointsFor(baseUrl?: string): readonly string[] {
+  const configured = baseUrl?.trim().replace(/\/+$/, "");
+  return configured && configured !== GEMINI_ENDPOINT ? [configured] : GEMINI_ENDPOINTS;
+}
+
+function isRecord(value: unknown): value is Record<string, unknown> {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+
+function timeoutSignal(signal?: AbortSignal): AbortSignal {
+  const timeout = AbortSignal.timeout(DISCOVERY_TIMEOUT_MS);
+  return signal ? AbortSignal.any([signal, timeout]) : timeout;
+}
+
+/** POSTs to one endpoint; undefined for any non-2xx or transport failure. */
+async function postJson(endpoint: string, path: string, token: string, body: unknown, signal?: AbortSignal): Promise<unknown> {
+  try {
+    const response = await fetch(`${endpoint}/v1internal:${path}`, {
+      method: "POST",
+      headers: geminiHeaders(token),
+      body: JSON.stringify(body),
+      signal: timeoutSignal(signal),
+    });
+    if (!response.ok) return undefined;
+    return await response.json();
+  } catch (error) {
+    // A caller abort is a decision, not an endpoint failure to route around.
+    if (signal?.aborted) throw error;
+    return undefined;
+  }
+}
+
+/** UUID-shaped id derived from a seed, so the same account always maps to the same value. */
+export function stableUuid(seed: string): string {
+  const bytes = createHash("sha1").update(seed).digest().subarray(0, 16);
+  bytes[6] = (bytes[6] & 0x0f) | 0x50;
+  bytes[8] = (bytes[8] & 0x3f) | 0x80;
+  const hex = bytes.toString("hex");
+  return `${hex.slice(0, 8)}-${hex.slice(8, 12)}-${hex.slice(12, 16)}-${hex.slice(16, 20)}-${hex.slice(20)}`;
+}
+
+/**
+ * Project for an account Google allocated none to. Consumer Gemini
+ * accounts are served without one, so a stable per-account value is enough;
+ * `PI_GEMINI_PROJECT_ID` pins a real one.
+ */
+export function fallbackProjectId(email?: string): string {
+  return geminiEnv("PROJECT_ID") ?? stableUuid(`antigravity:${email || "antigravity-default"}`);
+}
+
+/** The project field has moved between response shapes; accept each of them. */
+export function extractProjectId(data: unknown): string | undefined {
+  if (!isRecord(data)) return undefined;
+  const direct = data.geminiProjectId
+    ?? data.projectId
+    ?? data.backendProjectId
+    ?? data.userDefinedCloudaicompanionProject
+    ?? data.cloudaicompanionProject
+    ?? data.project;
+  if (typeof direct === "string" && direct) return direct;
+  if (isRecord(direct) && typeof direct.id === "string" && direct.id) return direct.id;
+
+  for (const key of ["projects", "projectIds", "cloudaicompanionProjects"]) {
+    const list = data[key];
+    if (!Array.isArray(list)) continue;
+    for (const item of list) {
+      if (typeof item === "string" && item) return item;
+      const nested = extractProjectId(item);
+      if (nested) return nested;
+    }
+  }
+  return undefined;
+}
+
+/**
+ * The account's project, or undefined when Google allocated none — callers
+ * then fall back to {@link fallbackProjectId}. `PI_GEMINI_PROJECT_ID` wins.
+ */
+export async function discoverProjectId(token: string, signal?: AbortSignal): Promise<string | undefined> {
+  const pinned = geminiEnv("PROJECT_ID");
+  if (pinned) return pinned;
+
+  for (const endpoint of GEMINI_ENDPOINTS) {
+    const status = await postJson(endpoint, "loadCodeAssist", token, { metadata: { ideType: "ANTIGRAVITY" } }, signal);
+    if (status === undefined) continue;
+    const project = extractProjectId(status);
+    if (project) return project;
+    // The account answered but carries no project: ask for its list instead.
+    for (const listing of GEMINI_ENDPOINTS) {
+      const projects = await postJson(listing, "listCloudAICompanionProjects", token, {}, signal);
+      if (projects !== undefined) return extractProjectId(projects);
+    }
+    return undefined;
+  }
+  return undefined;
+}
+
+/** Account label for the picker. Best effort: an account without it still works. */
+export async function fetchUserEmail(token: string, signal?: AbortSignal): Promise<string | undefined> {
+  try {
+    const response = await fetch("https://www.googleapis.com/oauth2/v1/userinfo?alt=json", {
+      headers: { Authorization: `Bearer ${token}` },
+      signal: timeoutSignal(signal),
+    });
+    if (!response.ok) return undefined;
+    const email = ((await response.json()) as { email?: unknown }).email;
+    return typeof email === "string" && email ? email : undefined;
+  } catch {
+    return undefined;
+  }
+}
+
+/** One entry of `fetchAvailableModels`, keyed by its runtime model id. */
+export interface RuntimeModelInfo {
+  isInternal?: boolean;
+  displayName?: string;
+  label?: string;
+  modelName?: string;
+  supportsThinking?: boolean;
+  supportsImages?: boolean;
+}
+
+/**
+ * The models this account can use, merged across every endpoint so rollouts
+ * that exist only on daily or sandbox still appear. Throws only when no
+ * endpoint answered at all.
+ */
+export async function fetchAvailableModels(
+  token: string,
+  projectId: string,
+  signal?: AbortSignal,
+): Promise<Record<string, RuntimeModelInfo>> {
+  const answers = await Promise.all(GEMINI_ENDPOINTS.map((endpoint) =>
+    postJson(endpoint, "fetchAvailableModels", token, { project: projectId }, signal)));
+
+  const catalogues = answers.filter(isRecord);
+  if (catalogues.length === 0) throw new Error("Gemini did not return a model list from any endpoint.");
+
+  const merged: Record<string, RuntimeModelInfo> = {};
+  for (const catalogue of catalogues) {
+    if (isRecord(catalogue.models)) Object.assign(merged, catalogue.models);
+  }
+  return merged;
+}

package/src/core/gemini/convert.ts

@@ -0,0 +1,239 @@
+import {
+  collapseSystemMessages,
+  withoutInitialSystemMessage,
+  type Api,
+  type AssistantMessage,
+  type Message,
+  type Model,
+  type TranscriptContext,
+} from "@earendil-works/pi-ai";
+
+/**
+ * pi messages → Gemini `contents`.
+ *
+ * A port of pi-ai's `convertMessages` / `transformMessages` from its Google
+ * adapter (MIT). pi does not supply that module to extensions — it hands out
+ * only its package root, `compat`, `oauth` and `providers/all`, and installs
+ * packages without their peers — so importing it resolves to nothing on a
+ * clean install. The behaviour is kept identical to pi's: thought-signature
+ * validation, cross-model thinking demoted to text, tool-call id
+ * normalisation, synthetic results for orphaned calls, and multimodal
+ * function responses. Re-check it against pi's adapter on a pi upgrade.
+ */
+
+export interface Part {
+  text?: string;
+  thought?: boolean;
+  thoughtSignature?: string;
+  inlineData?: { mimeType?: string; data?: string };
+  functionCall?: { name?: string; args?: Record<string, unknown>; id?: string };
+  functionResponse?: { name?: string; id?: string; response?: Record<string, unknown>; parts?: Part[] };
+}
+
+export interface Content {
+  role: "user" | "model";
+  parts: Part[];
+}
+
+/** Unpaired UTF-16 surrogates are rejected by the JSON the API parses. */
+export function sanitizeSurrogates(text: string): string {
+  return text.replace(/[\uD800-\uDBFF](?![\uDC00-\uDFFF])|(?<![\uD800-\uDBFF])[\uDC00-\uDFFF]/g, "");
+}
+
+// Thought signatures must be base64 (TYPE_BYTES); anything else is rejected.
+const BASE64 = /^[A-Za-z0-9+/]+={0,2}$/;
+const isValidSignature = (signature?: string): signature is string =>
+  !!signature && signature.length % 4 === 0 && BASE64.test(signature);
+
+function geminiMajor(modelId: string): number | undefined {
+  const match = /^gemini(?:-live)?-(\d+)/i.exec(modelId);
+  return match ? Number.parseInt(match[1], 10) : undefined;
+}
+
+/** Claude, GPT-OSS and Gemini 3+ need explicit ids on function calls and responses. */
+export function requiresToolCallId(modelId: string): boolean {
+  const major = geminiMajor(modelId);
+  return modelId.startsWith("claude-") || modelId.startsWith("gpt-oss-") || (major !== undefined && major >= 3);
+}
+
+function supportsMultimodalFunctionResponse(modelId: string): boolean {
+  const major = geminiMajor(modelId);
+  return major === undefined || major >= 3;
+}
+
+const USER_IMAGE_PLACEHOLDER = "(image omitted: model does not support images)";
+const TOOL_IMAGE_PLACEHOLDER = "(tool image omitted: model does not support images)";
+
+function withoutImages<T extends { type: string }>(content: T[], placeholder: string): T[] {
+  const result: T[] = [];
+  let previousWasPlaceholder = false;
+  for (const block of content) {
+    if (block.type === "image") {
+      if (!previousWasPlaceholder) result.push({ type: "text", text: placeholder } as unknown as T);
+      previousWasPlaceholder = true;
+      continue;
+    }
+    result.push(block);
+    previousWasPlaceholder = (block as { text?: string }).text === placeholder;
+  }
+  return result;
+}
+
+/**
+ * Makes a history replayable on `model`: another model's thinking becomes
+ * text, its signatures are dropped, its tool-call ids are normalised, failed
+ * turns are skipped, and every tool call is answered.
+ */
+function transformMessages(messages: Message[], model: Model<Api>, normalizeId: (id: string) => string): Message[] {
+  const idMap = new Map<string, string>();
+  const vision = model.input.includes("image");
+
+  const transformed = messages.map((raw): Message => {
+    const message = (raw.content == null ? { ...raw, content: [] } : raw) as Message;
+
+    if (message.role === "user") {
+      return !vision && Array.isArray(message.content)
+        ? { ...message, content: withoutImages(message.content, USER_IMAGE_PLACEHOLDER) }
+        : message;
+    }
+    if (message.role === "toolResult") {
+      const content = vision ? message.content : withoutImages(message.content, TOOL_IMAGE_PLACEHOLDER);
+      const toolCallId = idMap.get(message.toolCallId) ?? message.toolCallId;
+      return { ...message, content, toolCallId };
+    }
+    if (message.role !== "assistant") return message;
+
+    const sameModel = message.provider === model.provider && message.api === model.api && message.model === model.id;
+    const content = message.content.flatMap((block): AssistantMessage["content"] => {
+      if (block.type === "thinking") {
+        if (block.redacted) return sameModel ? [block] : [];
+        if (sameModel && block.thinkingSignature) return [block];
+        if (!block.thinking || block.thinking.trim() === "") return [];
+        return sameModel ? [block] : [{ type: "text", text: block.thinking }];
+      }
+      if (block.type === "text") return sameModel ? [block] : [{ type: "text", text: block.text }];
+      if (block.type === "toolCall" && !sameModel) {
+        const { thoughtSignature: _dropped, ...call } = block;
+        const id = normalizeId(block.id);
+        if (id !== block.id) idMap.set(block.id, id);
+        return [{ ...call, id }];
+      }
+      return [block];
+    });
+    return { ...message, content };
+  });
+
+  // Every tool call needs a result before the next turn; an unanswered one
+  // (an interrupted run, a user message mid-tool-flow) gets a synthetic error.
+  const result: Message[] = [];
+  let pending: { id: string; name: string }[] = [];
+  let answered = new Set<string>();
+  const closePending = () => {
+    for (const call of pending) {
+      if (answered.has(call.id)) continue;
+      result.push({
+        role: "toolResult",
+        toolCallId: call.id,
+        toolName: call.name,
+        content: [{ type: "text", text: "No result provided" }],
+        isError: true,
+        timestamp: Date.now(),
+      });
+    }
+    pending = [];
+    answered = new Set();
+  };
+
+  for (const message of transformed) {
+    if (message.role === "assistant") {
+      closePending();
+      // Incomplete turns are not replayed; the model resumes from the last good state.
+      if (message.stopReason === "error" || message.stopReason === "aborted") continue;
+      const calls = message.content.filter((block) => block.type === "toolCall");
+      if (calls.length > 0) {
+        pending = calls.map((call) => ({ id: call.id, name: call.name }));
+        answered = new Set();
+      }
+      result.push(message);
+    } else if (message.role === "toolResult") {
+      answered.add(message.toolCallId);
+      result.push(message);
+    } else {
+      if (message.role === "user") closePending();
+      result.push(message);
+    }
+  }
+  closePending();
+  return result;
+}
+
+/** Gemini `contents` for a transcript; the system prompt travels separately. */
+export function convertMessages(model: Model<Api>, context: TranscriptContext): Content[] {
+  // Gemini has no mid-conversation system messages; the prompt is systemInstruction.
+  const conversation = withoutInitialSystemMessage(collapseSystemMessages(context).messages);
+  const includeIds = requiresToolCallId(model.id);
+  const normalizeId = (id: string) => includeIds ? id.replace(/[^a-zA-Z0-9_-]/g, "_").slice(0, 64) : id;
+  const contents: Content[] = [];
+
+  for (const message of transformMessages(conversation, model, normalizeId)) {
+    if (message.role === "user") {
+      const parts: Part[] = typeof message.content === "string"
+        ? [{ text: sanitizeSurrogates(message.content) }]
+        : message.content.map((item) => item.type === "text"
+          ? { text: sanitizeSurrogates(item.text) }
+          : { inlineData: { mimeType: item.mimeType, data: item.data } });
+      if (parts.length > 0) contents.push({ role: "user", parts });
+    } else if (message.role === "assistant") {
+      const sameModel = message.provider === model.provider && message.model === model.id;
+      const signature = (value?: string) => sameModel && isValidSignature(value) ? value : undefined;
+      const parts: Part[] = [];
+
+      for (const block of message.content) {
+        if (block.type === "text") {
+          const thoughtSignature = signature(block.textSignature);
+          // An empty part that carries a signature must still be echoed back,
+          // or the reasoning chain breaks and turns end with an empty STOP.
+          if ((!block.text || block.text.trim() === "") && !thoughtSignature) continue;
+          parts.push({ text: sanitizeSurrogates(block.text), ...(thoughtSignature && { thoughtSignature }) });
+        } else if (block.type === "thinking") {
+          if (sameModel) {
+            const thoughtSignature = signature(block.thinkingSignature);
+            if ((!block.thinking || block.thinking.trim() === "") && !thoughtSignature) continue;
+            parts.push({ thought: true, text: sanitizeSurrogates(block.thinking), ...(thoughtSignature && { thoughtSignature }) });
+          } else if (block.thinking && block.thinking.trim() !== "") {
+            parts.push({ text: sanitizeSurrogates(block.thinking) });
+          }
+        } else if (block.type === "toolCall") {
+          const thoughtSignature = signature(block.thoughtSignature);
+          parts.push({
+            functionCall: { name: block.name, args: block.arguments ?? {}, ...(includeIds && { id: block.id }) },
+            ...(thoughtSignature && { thoughtSignature }),
+          });
+        }
+      }
+      if (parts.length > 0) contents.push({ role: "model", parts });
+    } else if (message.role === "toolResult") {
+      const text = message.content.filter((item) => item.type === "text").map((item) => item.text).join("\n");
+      const images = model.input.includes("image") ? message.content.filter((item) => item.type === "image") : [];
+      const imageParts: Part[] = images.map((image) => ({ inlineData: { mimeType: image.mimeType, data: image.data } }));
+      const nested = imageParts.length > 0 && supportsMultimodalFunctionResponse(model.id);
+      const value = text.length > 0 ? sanitizeSurrogates(text) : imageParts.length > 0 ? "(see attached image)" : "";
+
+      const part: Part = {
+        functionResponse: {
+          name: message.toolName,
+          response: message.isError ? { error: value } : { output: value },
+          ...(nested && { parts: imageParts }),
+          ...(includeIds && { id: message.toolCallId }),
+        },
+      };
+      // Every function response of a turn must share one user turn.
+      const last = contents.at(-1);
+      if (last?.role === "user" && last.parts.some((existing) => existing.functionResponse)) last.parts.push(part);
+      else contents.push({ role: "user", parts: [part] });
+
+      if (imageParts.length > 0 && !nested) contents.push({ role: "user", parts: [{ text: "Tool result image:" }, ...imageParts] });
+    }
+  }
+  return contents;
+}

package/src/core/gemini/credentials.ts

@@ -0,0 +1,56 @@
+import type { OAuthCredential } from "@earendil-works/pi-ai";
+
+/**
+ * A Gemini request needs two things per account: the OAuth access token
+ * and the Cloud Code project the account is served under. pi's OAuth path
+ * hands the stream only a `ModelAuth` (`apiKey`/`headers`/`baseUrl`), so the
+ * project has to travel inside one of those.
+ *
+ * It rides in `apiKey` rather than a header because a header would be sent to
+ * Google verbatim. The encoding is private to this provider: `toAuth()`
+ * produces it, the stream consumes it, and the account pool reads the token
+ * back out to attribute quota. All three share this one definition.
+ */
+
+export interface GeminiCredential extends OAuthCredential {
+  /** Project discovered at login; absent when Google allocated none. */
+  projectId?: string;
+  email?: string;
+}
+
+export interface GeminiApiKey {
+  token: string;
+  projectId: string;
+}
+
+export function encodeApiKey(key: GeminiApiKey): string {
+  return JSON.stringify({ token: key.token, projectId: key.projectId });
+}
+
+/** Throws with a recoverable instruction rather than letting Google answer 401. */
+export function decodeApiKey(apiKey: string | undefined): GeminiApiKey {
+  if (!apiKey) throw new Error("Gemini requires OAuth. Run /login gemini.");
+
+  let parsed: unknown;
+  try {
+    parsed = JSON.parse(apiKey);
+  } catch {
+    throw new Error("Gemini credentials are unreadable. Run /login gemini to re-authenticate.");
+  }
+
+  const { token, projectId } = (parsed ?? {}) as Partial<GeminiApiKey>;
+  if (typeof token !== "string" || !token || typeof projectId !== "string" || !projectId) {
+    throw new Error("Gemini credentials are missing a token or project. Run /login gemini.");
+  }
+  return { token, projectId };
+}
+
+export function credentialProjectId(credential: OAuthCredential): string | undefined {
+  const value = (credential as GeminiCredential).projectId;
+  return typeof value === "string" && value ? value : undefined;
+}
+
+export function credentialEmail(credential: OAuthCredential): string | undefined {
+  const value = (credential as GeminiCredential).email;
+  return typeof value === "string" && value ? value : undefined;
+}