@jameslovespancakes/pi-plus 1.0.16 → 1.0.18

package/README.md

@@ -73,6 +73,14 @@ Your live quota, always in the footer:
 With more than two accounts only the two most recently used are listed, so the
 footer stays a fixed height however many you pool.
 
+The right-hand column follows the model in use. It shows Codex by default and
+swaps to Gemini while a `gemini/*` model is selected: one bar per quota family
+(Flash, Pro, and Claude or GPT-OSS), pooled across your Gemini accounts, with
+the active family highlighted. Whether a family resets weekly or every five
+hours depends on the account's plan; the reset time shows which. Kimi and Grok
+publish no usage endpoint, so their column shows only the last rate-limit
+reading, if any.
+
 Account and routing commands are provider-agnostic. Sequential routing uses
 account order; quota-aware routing uses reported capacity and fairly probes
 accounts whose provider does not publish quota headers.

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@jameslovespancakes/pi-plus",
-  "version": "1.0.16",
+  "version": "1.0.18",
   "type": "module",
   "description": "pi and more",
   "license": "MIT",
@@ -49,10 +49,10 @@
     "ws": "^8.18.3"
   },
   "peerDependencies": {
-    "@earendil-works/pi-agent-core": "^0.87.0",
-    "@earendil-works/pi-ai": "^0.87.0",
-    "@earendil-works/pi-coding-agent": "^0.87.0",
-    "@earendil-works/pi-tui": "^0.87.0",
+    "@earendil-works/pi-agent-core": "*",
+    "@earendil-works/pi-ai": "*",
+    "@earendil-works/pi-coding-agent": "*",
+    "@earendil-works/pi-tui": "*",
     "typebox": "*"
   },
   "scripts": {

package/src/core/anthropic/models.ts

@@ -1,5 +1,8 @@
 import type { Model } from "@earendil-works/pi-ai";
-import { ANTHROPIC_MODELS as PI_ANTHROPIC_MODELS } from "@earendil-works/pi-ai/providers/anthropic.models";
+// `providers/all` is one of the entry points pi supplies from its own copy;
+// a deep `providers/anthropic.models` import has nothing to resolve against
+// on a clean install.
+import { getBuiltinModels } from "@earendil-works/pi-ai/providers/all";
 import { cachedAnthropicModels, type LiveModel } from "./catalog.ts";
 
 /**
@@ -106,7 +109,7 @@ function nameFor(model: LiveModel): string {
   return version ? `Claude ${pretty} ${version}` : `Claude ${pretty}`;
 }
 
-const base = Object.values(PI_ANTHROPIC_MODELS as unknown as Record<string, AnthropicModel>);
+const base = getBuiltinModels("anthropic") as unknown as AnthropicModel[];
 
 /**
  * Newest model per family, used as the template for a model the live list

package/src/core/anthropic/quota.ts

@@ -61,12 +61,16 @@ export function parseQuota(body: any, now = Date.now()): QuotaSnapshot {
     };
   };
 
+  // `limits` also restates the session and weekly windows (`kind: session`,
+  // `weekly_all`) with no scope. Only model-scoped entries are extra limits;
+  // keeping the others filed the 5h and 7d windows a second time as "scoped".
   const scoped = (Array.isArray(body?.limits) ? body.limits : [])
     .map((limit: any) => {
+      const name = limit?.scope?.model?.display_name;
       const used = pct(limit?.percent);
-      if (used === undefined) return undefined;
+      if (typeof name !== "string" || !name || used === undefined) return undefined;
       return {
-        id: String(limit?.scope?.model?.display_name ?? limit?.id ?? "scoped").toLowerCase(),
+        id: name.toLowerCase(),
         usedPercent: used,
         remainingPercent: 100 - used,
         resetsAt: typeof limit?.resets_at === "string" ? limit.resets_at : undefined,

package/src/core/gemini/client.ts

@@ -154,6 +154,45 @@ export async function fetchUserEmail(token: string, signal?: AbortSignal): Promi
   }
 }
 
+/** One `retrieveUserQuota` bucket: a runtime model's remaining share of its window. */
+export interface QuotaBucket {
+  modelId: string;
+  /** 0..1 of the window left. */
+  remainingFraction: number;
+  /** ISO time the window resets; absent for buckets with no window. */
+  resetTime?: string;
+}
+
+/**
+ * The account's quota, one bucket per runtime model id. Endpoints are tried in
+ * order and the first answer wins: quota is per account, not per endpoint.
+ * Throws only when no endpoint answered at all.
+ */
+export async function fetchUserQuota(
+  token: string,
+  projectId: string,
+  signal?: AbortSignal,
+): Promise<QuotaBucket[]> {
+  for (const endpoint of GEMINI_ENDPOINTS) {
+    const answer = await postJson(endpoint, "retrieveUserQuota", token, { project: projectId }, signal);
+    if (!isRecord(answer)) continue;
+    const buckets = Array.isArray(answer.buckets) ? answer.buckets : [];
+    return buckets.flatMap((bucket): QuotaBucket[] => {
+      if (!isRecord(bucket) || typeof bucket.modelId !== "string") return [];
+      // proto3 JSON omits zero values, so an exhausted bucket arrives with no
+      // `remainingFraction` at all. Absent means empty, not unknown.
+      const fraction = bucket.remainingFraction === undefined ? 0 : Number(bucket.remainingFraction);
+      if (!Number.isFinite(fraction)) return [];
+      return [{
+        modelId: bucket.modelId,
+        remainingFraction: Math.min(1, Math.max(0, fraction)),
+        ...(typeof bucket.resetTime === "string" && bucket.resetTime && { resetTime: bucket.resetTime }),
+      }];
+    });
+  }
+  throw new Error("Gemini did not return quota from any endpoint.");
+}
+
 /** One entry of `fetchAvailableModels`, keyed by its runtime model id. */
 export interface RuntimeModelInfo {
   isInternal?: boolean;

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/models.ts

@@ -1,5 +1,5 @@
 import type { Api, Model, ModelThinkingLevel, ThinkingLevelMap } from "@earendil-works/pi-ai";
-import { GOOGLE_MODELS } from "@earendil-works/pi-ai/providers/google.models";
+import { getBuiltinModels } from "@earendil-works/pi-ai/providers/all";
 import { GEMINI_ENDPOINT, type RuntimeModelInfo } from "./client.ts";
 
 /**
@@ -52,7 +52,7 @@ const familyOf = (id: string): Family => FAMILIES.find((family) => family.test.t
 
 /** pi's own definition of the same model, when its Google catalogue carries it. */
 function piModel(id: string): Model<Api> | undefined {
-  return (GOOGLE_MODELS as Record<string, Model<Api>>)[id];
+  return (getBuiltinModels("google") as Model<Api>[]).find((model) => model.id === id);
 }
 
 interface Definition {

package/src/core/gemini/quota.ts

@@ -0,0 +1,58 @@
+import type { QuotaBucket } from "./client.ts";
+
+/**
+ * Gemini quota, grouped the way the backend pools it.
+ *
+ * `retrieveUserQuota` answers per runtime model id (`gemini-3.8-flash-high`,
+ * `gemini-pro-agent`, `claude-opus-4-6-thinking`, …), but the ids of one
+ * family draw on one shared allowance: every Flash variant reports the same
+ * fraction and reset, as does every Pro variant. The window differs by plan —
+ * a paid account resets weekly, a free one every five hours — so the bars are
+ * labelled by family and the reset time says which window it is.
+ */
+
+export const GEMINI_QUOTA_FAMILIES = ["Flash", "Pro", "Claude", "GPT"] as const;
+export type GeminiQuotaFamily = typeof GEMINI_QUOTA_FAMILIES[number];
+
+/**
+ * The family a public or runtime model id draws quota from. Undefined for ids
+ * that are not agent models (tab completion, image, the `-lite` helpers the
+ * client uses for commit messages and search), so they never skew a family.
+ */
+export function geminiQuotaFamily(modelId: string | undefined): GeminiQuotaFamily | undefined {
+  const id = (modelId ?? "").toLowerCase();
+  if (id.startsWith("claude-")) return "Claude";
+  if (id.startsWith("gpt-oss")) return "GPT";
+  if (!id.startsWith("gemini-") || /image|lite/.test(id)) return undefined;
+  if (/(^|-)pro(-|$)/.test(id)) return "Pro";
+  if (/(^|-)flash(-|$)/.test(id)) return "Flash";
+  return undefined;
+}
+
+export interface GeminiFamilyQuota {
+  family: GeminiQuotaFamily;
+  /** Percent left, 0..100. */
+  remaining: number;
+  resetAt?: number;
+}
+
+/**
+ * One figure per family: the most depleted bucket in it, so a variant that
+ * has run dry is never hidden behind a sibling that has not.
+ */
+export function summarizeGeminiQuota(buckets: readonly QuotaBucket[]): GeminiFamilyQuota[] {
+  const byFamily = new Map<GeminiQuotaFamily, GeminiFamilyQuota>();
+  for (const bucket of buckets) {
+    const family = geminiQuotaFamily(bucket.modelId);
+    if (!family) continue;
+    const remaining = bucket.remainingFraction * 100;
+    const parsed = bucket.resetTime ? Date.parse(bucket.resetTime) : Number.NaN;
+    const resetAt = Number.isFinite(parsed) ? parsed : undefined;
+    const current = byFamily.get(family);
+    const lower = !current || remaining < current.remaining;
+    const sooner = current && remaining === current.remaining
+      && resetAt !== undefined && (current.resetAt === undefined || resetAt < current.resetAt);
+    if (lower || sooner) byFamily.set(family, { family, remaining, ...(resetAt !== undefined && { resetAt }) });
+  }
+  return GEMINI_QUOTA_FAMILIES.flatMap((family) => byFamily.get(family) ?? []);
+}

package/src/core/gemini/request.ts

@@ -1,42 +1,29 @@
-import type { Api, Model, ModelThinkingLevel, ToolChoice, TranscriptContext } from "@earendil-works/pi-ai";
-import { sanitizeSurrogates } from "@earendil-works/pi-ai/utils/sanitize-unicode";
-import { getCurrentSystemPrompt, getCurrentTools } from "@earendil-works/pi-ai/utils/transcript";
+import {
+  getCurrentSystemPrompt,
+  getCurrentTools,
+  type Api,
+  type Model,
+  type ModelThinkingLevel,
+  type Tool,
+  type ToolChoice,
+  type TranscriptContext,
+} from "@earendil-works/pi-ai";
 import { stableUuid } from "./client.ts";
+import { convertMessages, sanitizeSurrogates, type Content, type Part } from "./convert.ts";
 import { runtimeModelId, thinkingConfig } from "./models.ts";
 import { bridgeSchema, selfContainedSchema } from "./schema.ts";
 
 /**
  * Builds a Gemini `streamGenerateContent` request.
  *
- * Inside the envelope the body is ordinary Gemini, so message conversion,
- * thought-signature validation, tool-call ids and function-calling mode all
- * come from pi's own Google adapter. What is added here is only what this
- * backend demands beyond the public Gemini API: the runtime model id, its
- * thinking budget, the Claude/GPT-OSS schema bridge, a few conversation-shape
- * repairs it enforces, and the agent envelope it expects.
+ * Inside the envelope the body is ordinary Gemini, converted the way pi's
+ * own Google adapter converts it (see convert.ts). What is added here is only
+ * what this backend demands beyond the public Gemini API: the runtime model
+ * id, its thinking budget, the Claude/GPT-OSS schema bridge, a few
+ * conversation-shape repairs it enforces, and the agent envelope it expects.
  */
 
-type GoogleShared = typeof import("@earendil-works/pi-ai/api/google-shared");
-let googleSharedModule: Promise<GoogleShared> | undefined;
-
-/** Loaded on first request, as pi loads its own Google adapter: it pulls in `@google/genai`. */
-export function googleShared(): Promise<GoogleShared> {
-  return googleSharedModule ??= import("@earendil-works/pi-ai/api/google-shared");
-}
-
-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[];
-}
+export type { Content, Part };
 
 export interface RequestOptions {
   /** Level after pi's clamp; undefined means thinking off. */
@@ -158,15 +145,23 @@ export function repairContents(contents: Content[], requireSignatures: boolean):
   return turns;
 }
 
-function toolDeclarations(declared: { functionDeclarations: Record<string, unknown>[] }[], bridge: boolean) {
-  return declared.map((group) => ({
-    functionDeclarations: group.functionDeclarations.map(({ parametersJsonSchema, parameters, ...rest }) => ({
-      ...rest,
+function toolDeclarations(tools: Tool[], bridge: boolean) {
+  return [{
+    functionDeclarations: tools.map((tool) => ({
+      name: tool.name,
+      description: tool.description,
       ...(bridge
-        ? { parameters: bridgeSchema(parametersJsonSchema ?? parameters) }
-        : { parametersJsonSchema: selfContainedSchema(parametersJsonSchema ?? parameters) }),
+        ? { parameters: bridgeSchema(tool.parameters) }
+        : { parametersJsonSchema: selfContainedSchema(tool.parameters) }),
     })),
-  }));
+  }];
+}
+
+/** pi's tool choice as Gemini's calling mode; omitted unless asked, as pi does. */
+function callingMode(toolChoice: RequestOptions["toolChoice"]): string | undefined {
+  if (toolChoice === "none") return "NONE";
+  if (toolChoice === "any") return "ANY";
+  return toolChoice ? "AUTO" : undefined;
 }
 
 /** Random signed 64-bit decimal, the shape the Antigravity CLI uses for session ids. */
@@ -204,32 +199,21 @@ function envelope(context: TranscriptContext, contents: Content[], runtimeId: st
   };
 }
 
-export async function buildRequest(
+export function buildRequest(
   model: Model<Api>,
   context: TranscriptContext,
   projectId: string,
   options: RequestOptions = {},
-): Promise<GeminiRequest> {
-  const google = await googleShared();
-  // pi's Google helpers are typed against its own Google APIs; the body inside
-  // the envelope has exactly the same model semantics.
-  const googleModel = model as unknown as Model<"google-generative-ai">;
+): GeminiRequest {
   const runtimeId = runtimeModelId(model, options.reasoning);
-
-  const contents = repairContents(
-    google.convertMessages(googleModel, context) as unknown as Content[],
-    requiresThoughtSignatures(runtimeId),
-  );
+  const contents = repairContents(convertMessages(model, context), requiresThoughtSignatures(runtimeId));
 
   // The system prompt and tools live in the transcript's system messages,
   // never on the context object; reading them any other way sends neither.
   const systemPrompt = getCurrentSystemPrompt(context.messages);
   const tools = getCurrentTools(context.messages);
   // Strict tool sampling (Gemini's VALIDATED mode) is not offered by this backend.
-  const declared = google.convertTools(tools, false, false);
-  const mode = tools.length > 0
-    ? google.resolveGoogleFunctionCallingMode(tools, options.toolChoice, false)
-    : undefined;
+  const mode = tools.length > 0 ? callingMode(options.toolChoice) : undefined;
 
   const thinking = thinkingConfig(runtimeId, options.reasoning);
   const generationConfig = {
@@ -247,7 +231,7 @@ export async function buildRequest(
       contents,
       ...(systemPrompt && { systemInstruction: { role: "user", parts: [{ text: sanitizeSurrogates(systemPrompt) }] } }),
       generationConfig,
-      ...(declared && { tools: toolDeclarations(declared, usesToolBridge(runtimeId)) }),
+      ...(tools.length > 0 && { tools: toolDeclarations(tools, usesToolBridge(runtimeId)) }),
       ...(mode !== undefined && { toolConfig: { functionCallingConfig: { mode } } }),
       sessionId,
       labels,