@oh-my-pi/pi-ai 16.0.3 → 16.0.5

package/CHANGELOG.md

@@ -2,6 +2,42 @@
 
 ## [Unreleased]
 
+## [16.0.5] - 2026-06-17
+
+### Added
+
+- Added `antigravityEndpointMode` stream option with `auto`, `production`, and `sandbox` values to control Antigravity endpoint routing
+- Added `seedApiKeyResolver` for reusing a pre-resolved request key while preserving resolver-driven auth retry and credential rotation
+- Added optional `contextSnapshot` property to `AssistantMessage` with token usage metadata via new `ContextSnapshot` interface (`promptTokens`, `nonMessageTokens`, and optional `lastMessageTimestamp`)
+- Added `LITELLM_BASE_URL` guidance to the LiteLLM login prompt so non-default proxy endpoints are discoverable. ([#2726](https://github.com/can1357/oh-my-pi/issues/2726))
+- Added a Gemini thinking-loop guard that watches streamed `thinking` deltas for degenerate reasoning loops — verbatim tail repetition and near-duplicate paragraph cycling — and terminates the stream with a retryable, empty-content `error` message (worded as a transient stream stall) so the turn is discarded and re-sampled instead of committing a runaway transcript. Gated to Gemini models across every transport (OpenRouter, direct Google, Vertex) and disarmed once visible answer text or a tool call starts; disable with `PI_NO_THINKING_LOOP_GUARD=1`.
+
+### Changed
+
+- Changed the Antigravity (`google-antigravity`) request builder to mirror the captured `antigravity/hub` client: gemini-3.x send `thinkingConfig.thinkingBudget` per tier, a fixed per-model `maxOutputTokens`, a default `functionCallingConfig.mode: "VALIDATED"` tool mode (auto/unset tool choice only), a `role: "user"` system instruction, a structured `requestId` (`agent/<id>/<ts>/<trajectoryId>/<step>`), and `labels` (`model_enum`, `trajectory_id`, `last_step_index`, `last_execution_id`, `used_claude*`) tracked across the conversation via provider session state.
+
+### Fixed
+
+- Fixed Gemini usage-tier mapping so `gemini-3.5-flash` is treated as `Flash` and `gemini-3.1-pro` plus `gemini-pro-agent` are treated as `Pro` in usage accounting
+- Fixed Antigravity stream state handling so a request’s `last_execution_id` is committed only after a successful completion and cleared between retry attempts
+- Fixed `streamSimple()` Gemini streams to run through the thinking-loop guard for custom API and pi-native transports, so degenerate `thinking` loops now abort with the same retryable empty-content error path as other Gemini stream paths
+- Fixed Antigravity model streaming and usage fetch paths to retry on transient `429`/`5xx` errors by failing over to the alternate endpoint before surfacing an error
+- Fixed Antigravity endpoint tracking to prefer a previously successful endpoint in `auto` mode for subsequent requests
+- Fixed Antigravity and Gemini CLI model requests failing with an opaque error when Google requires account verification. Cloud Code Assist `403 VALIDATION_REQUIRED` responses now surface the `validation_url` and the signed-in account email when available, so users see an actionable account-verification message instead of the raw API error body.
+- Fixed MiniMax M3 in-band tool calls by adding a MiniMax dialect that parses `<minimax:tool_call>` wrappers instead of falling back to generic XML. ([#2759](https://github.com/can1357/oh-my-pi/issues/2759))
+- Fixed GitHub Copilot OAuth for Business seats by storing the login-discovered API endpoint and routing model enablement plus chat requests to that endpoint. ([#2876](https://github.com/can1357/oh-my-pi/issues/2876))
+
+## [16.0.4] - 2026-06-17
+
+### Fixed
+
+- Fixed tool argument coercion to parse double-encoded JSON strings, including quoted values like `"300"`, when schema expects a number
+- Fixed object-array coercion to parse JSON object and array strings into proper array arguments instead of wrapping raw strings
+- Fixed handling of malformed JSON container strings for array schema fields so validation now surfaces a top-level `expected array, received string` error rather than nested element errors
+- Fixed ChatGPT/Codex browser login missing connector OAuth scopes and rendering object-shaped token endpoint errors as `[object Object]`. ([#2825](https://github.com/can1357/oh-my-pi/issues/2825))
+- Fixed Zhipu/BigModel GLM-5.2 chat-completions requests so internal `xhigh` effort serializes as provider-native `reasoning_effort: "max"` and tool calls opt into `tool_stream`. ([#2833](https://github.com/can1357/oh-my-pi/issues/2833))
+- Fixed Google Gemini CLI and Antigravity tool calls with `toolChoice: "auto"` serializing an explicit `toolConfig` AUTO mode, which can cause Gemini-3 models to leak raw planning JSON instead of executing tools. ([#2830](https://github.com/can1357/oh-my-pi/issues/2830))
+
 ## [16.0.3] - 2026-06-16
 
 ### Added

package/dist/types/auth-broker/wire-schemas.d.ts

@@ -15,6 +15,7 @@
 import { z } from "zod/v4";
 /** Real OAuth credential (broker-side) — refresh token is the actual upstream value. */
 export declare const oauthCredentialSchema: z.ZodObject<{
+    apiEndpoint: z.ZodOptional<z.ZodString>;
     type: z.ZodLiteral<"oauth">;
     refresh: z.ZodString;
     access: z.ZodString;
@@ -26,6 +27,7 @@ export declare const oauthCredentialSchema: z.ZodObject<{
 }, z.core.$loose>;
 /** OAuth credential as it appears in broker snapshots — refresh replaced with sentinel. */
 export declare const remoteOauthCredentialSchema: z.ZodObject<{
+    apiEndpoint: z.ZodOptional<z.ZodString>;
     type: z.ZodLiteral<"oauth">;
     access: z.ZodString;
     expires: z.ZodNumber;
@@ -41,6 +43,7 @@ export declare const apiKeyCredentialSchema: z.ZodObject<{
 }, z.core.$strict>;
 /** Discriminated union accepted on POST /v1/credential (writes). */
 export declare const writableAuthCredentialSchema: z.ZodDiscriminatedUnion<[z.ZodObject<{
+    apiEndpoint: z.ZodOptional<z.ZodString>;
     type: z.ZodLiteral<"oauth">;
     refresh: z.ZodString;
     access: z.ZodString;
@@ -55,6 +58,7 @@ export declare const writableAuthCredentialSchema: z.ZodDiscriminatedUnion<[z.Zo
 }, z.core.$strict>], "type">;
 /** Discriminated union returned in snapshots (refresh is sentinel for OAuth). */
 export declare const snapshotCredentialSchema: z.ZodDiscriminatedUnion<[z.ZodObject<{
+    apiEndpoint: z.ZodOptional<z.ZodString>;
     type: z.ZodLiteral<"oauth">;
     access: z.ZodString;
     expires: z.ZodNumber;
@@ -71,6 +75,7 @@ export declare const credentialSnapshotEntrySchema: z.ZodObject<{
     id: z.ZodNumber;
     provider: z.ZodString;
     credential: z.ZodDiscriminatedUnion<[z.ZodObject<{
+        apiEndpoint: z.ZodOptional<z.ZodString>;
         type: z.ZodLiteral<"oauth">;
         access: z.ZodString;
         expires: z.ZodNumber;
@@ -89,6 +94,7 @@ export declare const snapshotEntrySchema: z.ZodObject<{
     id: z.ZodNumber;
     provider: z.ZodString;
     credential: z.ZodDiscriminatedUnion<[z.ZodObject<{
+        apiEndpoint: z.ZodOptional<z.ZodString>;
         type: z.ZodLiteral<"oauth">;
         access: z.ZodString;
         expires: z.ZodNumber;
@@ -124,6 +130,7 @@ export declare const snapshotResponseSchema: z.ZodObject<{
         id: z.ZodNumber;
         provider: z.ZodString;
         credential: z.ZodDiscriminatedUnion<[z.ZodObject<{
+            apiEndpoint: z.ZodOptional<z.ZodString>;
             type: z.ZodLiteral<"oauth">;
             access: z.ZodString;
             expires: z.ZodNumber;
@@ -155,6 +162,7 @@ export declare const snapshotStreamSnapshotEventSchema: z.ZodObject<{
         id: z.ZodNumber;
         provider: z.ZodString;
         credential: z.ZodDiscriminatedUnion<[z.ZodObject<{
+            apiEndpoint: z.ZodOptional<z.ZodString>;
             type: z.ZodLiteral<"oauth">;
             access: z.ZodString;
             expires: z.ZodNumber;
@@ -187,6 +195,7 @@ export declare const snapshotStreamEntryEventSchema: z.ZodObject<{
         id: z.ZodNumber;
         provider: z.ZodString;
         credential: z.ZodDiscriminatedUnion<[z.ZodObject<{
+            apiEndpoint: z.ZodOptional<z.ZodString>;
             type: z.ZodLiteral<"oauth">;
             access: z.ZodString;
             expires: z.ZodNumber;
@@ -231,6 +240,7 @@ export declare const snapshotStreamEventSchema: z.ZodDiscriminatedUnion<[z.ZodOb
         id: z.ZodNumber;
         provider: z.ZodString;
         credential: z.ZodDiscriminatedUnion<[z.ZodObject<{
+            apiEndpoint: z.ZodOptional<z.ZodString>;
             type: z.ZodLiteral<"oauth">;
             access: z.ZodString;
             expires: z.ZodNumber;
@@ -261,6 +271,7 @@ export declare const snapshotStreamEventSchema: z.ZodDiscriminatedUnion<[z.ZodOb
         id: z.ZodNumber;
         provider: z.ZodString;
         credential: z.ZodDiscriminatedUnion<[z.ZodObject<{
+            apiEndpoint: z.ZodOptional<z.ZodString>;
             type: z.ZodLiteral<"oauth">;
             access: z.ZodString;
             expires: z.ZodNumber;
@@ -358,6 +369,7 @@ export declare const credentialRefreshResponseSchema: z.ZodObject<{
         id: z.ZodNumber;
         provider: z.ZodString;
         credential: z.ZodDiscriminatedUnion<[z.ZodObject<{
+            apiEndpoint: z.ZodOptional<z.ZodString>;
             type: z.ZodLiteral<"oauth">;
             access: z.ZodString;
             expires: z.ZodNumber;
@@ -382,6 +394,7 @@ export declare const credentialDisableResponseSchema: z.ZodObject<{
 export declare const credentialUploadRequestSchema: z.ZodObject<{
     provider: z.ZodString;
     credential: z.ZodDiscriminatedUnion<[z.ZodObject<{
+        apiEndpoint: z.ZodOptional<z.ZodString>;
         type: z.ZodLiteral<"oauth">;
         refresh: z.ZodString;
         access: z.ZodString;
@@ -400,6 +413,7 @@ export declare const credentialUploadResponseSchema: z.ZodObject<{
         id: z.ZodNumber;
         provider: z.ZodString;
         credential: z.ZodDiscriminatedUnion<[z.ZodObject<{
+            apiEndpoint: z.ZodOptional<z.ZodString>;
             type: z.ZodLiteral<"oauth">;
             access: z.ZodString;
             expires: z.ZodNumber;

package/dist/types/auth-retry.d.ts

@@ -37,6 +37,15 @@ export declare function isApiKeyResolver(key: ApiKey | undefined): key is ApiKey
  * `lastChance: false`). Static keys pass through unchanged.
  */
 export declare function resolveApiKeyOnce(key: ApiKey | undefined, signal?: AbortSignal): Promise<string | undefined>;
+/**
+ * Wraps a resolver with a bearer that was already selected for this request.
+ *
+ * Callers that preflight credentials can pass the returned resolver to the
+ * auth-retry driver without making the driver know about that preflight: the
+ * first initial resolution reuses `seed`, and all later resolutions delegate to
+ * `resolver`.
+ */
+export declare function seedApiKeyResolver(seed: string | undefined, resolver: ApiKeyResolver): ApiKeyResolver;
 /**
  * Classifies whether an error should trigger a credential refresh/rotation
  * retry: a hard `401`, or a rotatable usage-limit ("usage_limit_reached",

package/dist/types/auth-storage.d.ts

@@ -139,6 +139,7 @@ export type CompletionProbeCredential = {
     projectId?: string;
     email?: string;
     enterpriseUrl?: string;
+    apiEndpoint?: string;
 };
 /**
  * Caller-supplied bearer probe. Receives the post-refresh credential for a
@@ -435,6 +436,7 @@ export interface OAuthAccess {
     email?: string;
     projectId?: string;
     enterpriseUrl?: string;
+    apiEndpoint?: string;
 }
 export interface OAuthAccessFailure {
     credentialId?: number;
@@ -442,6 +444,7 @@ export interface OAuthAccessFailure {
     email?: string;
     projectId?: string;
     enterpriseUrl?: string;
+    apiEndpoint?: string;
     error: string;
 }
 /**

package/dist/types/dialect/anthropic.d.ts

@@ -1,7 +1,13 @@
 import type { DialectDefinition, InbandScanEvent, InbandScanner, InbandScannerOptions } from "./types";
+export declare const ANTHROPIC_THINKING_TAG_PREFIXES: readonly ["<thinking", "</thinking", "<think", "</think", "<scratchpad", "</scratchpad", "<antml:thinking", "</antml:thinking", "<antml:think", "</antml:think", "<antml:scratchpad", "</antml:scratchpad"];
+export interface AnthropicInbandScannerConfig {
+    readonly wrapperTags?: Readonly<Record<string, true>>;
+    readonly baseTagPrefixes?: readonly string[];
+    readonly allTagPrefixes?: readonly string[];
+}
 export declare class AnthropicInbandScanner implements InbandScanner {
     #private;
-    constructor(options?: InbandScannerOptions);
+    constructor(options?: InbandScannerOptions, config?: AnthropicInbandScannerConfig);
     feed(text: string): InbandScanEvent[];
     flush(): InbandScanEvent[];
 }

package/dist/types/dialect/minimax.d.ts

@@ -0,0 +1,3 @@
+import type { DialectDefinition } from "./types";
+declare const definition: DialectDefinition;
+export default definition;

package/dist/types/index.d.ts

@@ -41,4 +41,5 @@ export * from "./utils/event-stream";
 export * from "./utils/overflow";
 export * from "./utils/retry";
 export * from "./utils/schema";
+export * from "./utils/thinking-loop";
 export * from "./utils/validation";

package/dist/types/providers/google-gemini-cli.d.ts

@@ -1,5 +1,5 @@
 import { ProviderHttpError } from "../errors";
-import type { Context, Model, StreamFunction, StreamOptions } from "../types";
+import type { Context, Model, ProviderSessionState, StreamFunction, StreamOptions } from "../types";
 import type { Content, FunctionCallingConfigMode, ThinkingConfig } from "./google-shared";
 import { type GoogleThinkingLevel } from "./google-shared";
 /**
@@ -52,13 +52,33 @@ export interface GoogleGeminiCliOptions extends StreamOptions {
      */
     requestModelId?: string;
     projectId?: string;
+    /** Antigravity endpoint routing mode: "auto" (default with failover), "production", "sandbox". */
+    antigravityEndpointMode?: "auto" | "production" | "sandbox";
+    providerSessionState?: Map<string, ProviderSessionState>;
 }
-export { ANTIGRAVITY_NO_PREAMBLE_INSTRUCTION, ANTIGRAVITY_SYSTEM_INSTRUCTION, getAntigravityUserAgent, getGeminiCliHeaders, getGeminiCliUserAgent, } from "@oh-my-pi/pi-catalog/wire/gemini-headers";
+export interface AntigravityProviderSessionState extends ProviderSessionState {
+    lastGoodEndpoint?: string;
+    /**
+     * Per-conversation request-envelope identity that mirrors the real
+     * Antigravity client. `sessionId` is the signed-decimal session id;
+     * `agentId`/`trajectoryId` are UUIDs; `stepIndex` is the monotonic step
+     * counter; `lastExecutionId` is the prior response id echoed as
+     * `labels.last_execution_id`.
+     */
+    agentId?: string;
+    trajectoryId?: string;
+    sessionId?: string;
+    stepIndex?: number;
+    lastExecutionId?: string;
+}
+export declare function getAntigravityProviderSessionState(providerSessionState: Map<string, ProviderSessionState> | undefined): AntigravityProviderSessionState | undefined;
+export { ANTIGRAVITY_SYSTEM_INSTRUCTION, getAntigravityUserAgent, getGeminiCliHeaders, getGeminiCliUserAgent, } from "@oh-my-pi/pi-catalog/wire/gemini-headers";
 interface ParsedGeminiCliCredentials {
     accessToken: string;
     projectId: string;
     refreshToken?: string;
     expiresAt?: number;
+    email?: string;
 }
 export declare function parseGeminiCliCredentials(apiKeyRaw: string): ParsedGeminiCliCredentials;
 export declare function shouldRefreshGeminiCliCredentials(expiresAt: number | undefined, isAntigravity: boolean, nowMs?: number): boolean;
@@ -93,6 +113,7 @@ interface CloudCodeAssistRequest {
                 allowedFunctionNames?: string[];
             };
         };
+        labels?: Record<string, string>;
     };
     requestType?: string;
     userAgent?: string;

package/dist/types/providers/openai-completions.d.ts

@@ -21,6 +21,8 @@ export interface OpenAICompletionsOptions extends StreamOptions {
     /** Force-disable reasoning where supported, or request the lowest effort on generic effort endpoints. */
     disableReasoning?: boolean;
     serviceTier?: ServiceTier;
+    /** @internal True when maxTokens came from the caller, not the model default. */
+    maxTokensExplicit?: boolean;
     /**
      * Routing-variant suffix appended to OpenRouter model IDs when none is
      * already present (`anthropic/claude-haiku-latest` → `…:nitro`). Common

package/dist/types/registry/alibaba-coding-plan.d.ts

@@ -1,7 +1,8 @@
-import type { OAuthController, OAuthLoginCallbacks } from "./oauth/types";
-export declare function loginAlibabaCodingPlan(options: OAuthController): Promise<string>;
+import type { OAuthController, OAuthCredentials, OAuthLoginCallbacks } from "./oauth/types";
+export declare function loginAlibabaCodingPlan(options: OAuthController): Promise<OAuthCredentials>;
 export declare const alibabaCodingPlanProvider: {
     readonly id: "alibaba-coding-plan";
     readonly name: "Alibaba Coding Plan";
-    readonly login: (cb: OAuthLoginCallbacks) => Promise<string>;
+    readonly login: (cb: OAuthLoginCallbacks) => Promise<OAuthCredentials>;
+    readonly getApiKey: (credentials: OAuthCredentials) => string;
 };

package/dist/types/registry/oauth/github-copilot.d.ts

@@ -17,7 +17,7 @@ type GitHubCopilotLoginOptions = {
  * Refresh GitHub Copilot token.
  * With the opencode OAuth flow, the GitHub token is used directly — no JWT exchange needed.
  */
-export declare function refreshGitHubCopilotToken(refreshToken: string, enterpriseDomain?: string): OAuthCredentials;
+export declare function refreshGitHubCopilotToken(refreshToken: string, enterpriseDomain?: string, apiEndpoint?: string): OAuthCredentials;
 /**
  * Login with GitHub Copilot OAuth (device code flow)
  *

package/dist/types/registry/oauth/google-oauth-shared.d.ts

@@ -1,9 +1,3 @@
-/**
- * Shared OAuth flow for Google-style providers (Gemini CLI, Antigravity).
- *
- * Both providers use the same authorization-code flow shape; only the client
- * credentials, scopes, endpoint constants, and project-discovery logic differ.
- */
 import { OAuthCallbackFlow } from "./callback-server";
 import type { OAuthController, OAuthCredentials } from "./types";
 export interface GoogleOAuthFlowConfig {

package/dist/types/registry/oauth/openai-codex.d.ts

@@ -3,6 +3,8 @@
  */
 import type { OAuthController, OAuthCredentials } from "./types";
 export declare function decodeJwt<T = Record<string, unknown>>(token: string): T | null;
+/** Formats OpenAI Codex OAuth token endpoint errors for login and refresh failures. */
+export declare function formatOpenAICodexTokenEndpointError(status: number, bodyText: string): string;
 /** Builds the Codex browser OAuth URL used by browser login; exported for auth regression tests. */
 export declare function createOpenAICodexAuthorizationUrl(args: {
     state: string;

package/dist/types/registry/oauth/types.d.ts

@@ -8,6 +8,7 @@ export type OAuthCredentials = {
     projectId?: string;
     email?: string;
     accountId?: string;
+    apiEndpoint?: string;
 };
 export type OAuthProvider = OAuthProviderUnion;
 export type OAuthProviderId = OAuthProvider | (string & {});

package/dist/types/registry/registry.d.ts

@@ -12,7 +12,8 @@ declare const ALL: ({
 } | {
     readonly id: "alibaba-coding-plan";
     readonly name: "Alibaba Coding Plan";
-    readonly login: (cb: import("./oauth").OAuthLoginCallbacks) => Promise<string>;
+    readonly login: (cb: import("./oauth").OAuthLoginCallbacks) => Promise<import("./oauth").OAuthCredentials>;
+    readonly getApiKey: (credentials: import("./oauth").OAuthCredentials) => string;
 } | {
     readonly id: "amazon-bedrock";
     readonly name: "Amazon Bedrock";

package/dist/types/types.d.ts

@@ -304,6 +304,8 @@ export interface SimpleStreamOptions extends Omit<StreamOptions, "apiKey"> {
      * or the catalog entry already names the variant).
      */
     openrouterVariant?: string;
+    /** Antigravity endpoint routing mode: "auto" (default with failover), "production", "sandbox". */
+    antigravityEndpointMode?: "auto" | "production" | "sandbox";
 }
 export type StreamFunction<TApi extends Api> = (model: Model<TApi>, context: Context, options: OptionsForApi<TApi>) => AssistantMessageEventStream;
 export interface TextSignatureV1 {
@@ -388,12 +390,18 @@ export interface DeveloperMessage {
     providerPayload?: ProviderPayload;
     timestamp: number;
 }
+export interface ContextSnapshot {
+    promptTokens: number;
+    nonMessageTokens: number;
+    lastMessageTimestamp?: number;
+}
 export interface AssistantMessage {
     role: "assistant";
     content: (TextContent | ThinkingContent | RedactedThinkingContent | ToolCall)[];
     api: Api;
     provider: Provider;
     model: string;
+    contextSnapshot?: ContextSnapshot;
     responseId?: string;
     /**
      * Name of the upstream provider an aggregator routed this request to, as

package/dist/types/usage.d.ts

@@ -277,6 +277,7 @@ export interface UsageCredential {
     email?: string;
     enterpriseUrl?: string;
     metadata?: Record<string, unknown>;
+    apiEndpoint?: string;
 }
 /** Parameters provided to a usage fetcher. */
 export interface UsageFetchParams {

package/dist/types/utils/google-validation.d.ts

@@ -0,0 +1,2 @@
+export declare function extractGoogleValidationUrl(errorBody: string): string | undefined;
+export declare function formatGoogleValidationRequiredMessage(validationUrl: string, nextAction: string, email?: string): string;

package/dist/types/utils/thinking-loop.d.ts

@@ -0,0 +1,45 @@
+import type { Api, Model } from "../types";
+import { AssistantMessageEventStream } from "./event-stream";
+/** Stable lead phrase of the guard's error message; exported for tests. The
+ *  message also carries "stream stall" so the session + transport retry
+ *  classifiers treat it as a transient (retryable) stop without bespoke rules. */
+export declare const THINKING_LOOP_ERROR_MARKER = "Thinking loop detected";
+/**
+ * True when `model` should be guarded for thinking loops (Gemini only).
+ *
+ * OpenAI-compat transports can serve Gemini under an arbitrary provider/id, so
+ * for those we trust the family-derived (and user-overridable)
+ * `compat.enableGeminiThinkingLoopGuard` flag set by the catalog. Direct Google
+ * transports always carry a clearly gemini-shaped id/provider, so a string
+ * match is sufficient (and works for hand-built models without a compat record).
+ */
+export declare function isGeminiThinkingLoopModel(model: Model<Api>): boolean;
+/**
+ * Stateful detector fed the streamed thinking deltas. `push` returns a
+ * human-readable reason the first time a loop shape is recognized; the caller
+ * is responsible for stopping after the first hit.
+ */
+export declare class ThinkingLoopDetector {
+    #private;
+    push(delta: string): string | null;
+    /** Process the buffered trailing paragraph (one with no blank-line / heading
+     *  terminator). Called when the thinking block ends so the final segment —
+     *  which may be the one that completes a duplicate cluster — is not dropped. */
+    flush(): string | null;
+}
+/**
+ * Wrap a provider stream with the loop guard. `controller` is the guard's own
+ * abort handle: aborting it (after wiring it into the provider's signal via
+ * {@link withGeminiThinkingLoopGuard}) tears down the upstream once a loop
+ * trips.
+ */
+export declare function guardThinkingLoopStream(inner: AssistantMessageEventStream, model: Model<Api>, controller: AbortController): AssistantMessageEventStream;
+/**
+ * Apply the Gemini loop guard around a provider dispatch. For non-Gemini models
+ * (or when disabled) this is a transparent pass-through. For Gemini it injects a
+ * guard abort signal into the provider call so a detected loop tears down the
+ * upstream, then wraps the returned stream.
+ */
+export declare function withGeminiThinkingLoopGuard<O extends {
+    signal?: AbortSignal;
+}>(model: Model<Api>, options: O | undefined, dispatch: (options: O | undefined) => AssistantMessageEventStream): AssistantMessageEventStream;

package/package.json

@@ -1,7 +1,7 @@
 {
 	"type": "module",
 	"name": "@oh-my-pi/pi-ai",
-	"version": "16.0.3",
+	"version": "16.0.5",
 	"description": "Unified LLM API with automatic model discovery and provider configuration",
 	"homepage": "https://omp.sh",
 	"author": "Can Boluk",
@@ -38,8 +38,8 @@
 	},
 	"dependencies": {
 		"@bufbuild/protobuf": "^2.12.0",
-		"@oh-my-pi/pi-catalog": "16.0.3",
-		"@oh-my-pi/pi-utils": "16.0.3",
+		"@oh-my-pi/pi-catalog": "16.0.5",
+		"@oh-my-pi/pi-utils": "16.0.5",
 		"partial-json": "^0.1.7",
 		"zod": "^4"
 	},

package/src/auth-broker/wire-schemas.ts

@@ -21,6 +21,7 @@ import { usageReportSchema } from "../usage";
 /** Real OAuth credential (broker-side) — refresh token is the actual upstream value. */
 export const oauthCredentialSchema = z
 	.object({
+		apiEndpoint: z.string().optional(),
 		type: z.literal("oauth"),
 		refresh: z
 			.string()

package/src/auth-retry.ts

@@ -51,6 +51,25 @@ export async function resolveApiKeyOnce(key: ApiKey | undefined, signal?: AbortS
 	return key;
 }
 
+/**
+ * Wraps a resolver with a bearer that was already selected for this request.
+ *
+ * Callers that preflight credentials can pass the returned resolver to the
+ * auth-retry driver without making the driver know about that preflight: the
+ * first initial resolution reuses `seed`, and all later resolutions delegate to
+ * `resolver`.
+ */
+export function seedApiKeyResolver(seed: string | undefined, resolver: ApiKeyResolver): ApiKeyResolver {
+	let seedPending = seed !== undefined;
+	return ctx => {
+		if (seedPending && ctx.error === undefined) {
+			seedPending = false;
+			return seed;
+		}
+		return resolver(ctx);
+	};
+}
+
 /**
  * Classifies whether an error should trigger a credential refresh/rotation
  * retry: a hard `401`, or a rotatable usage-limit ("usage_limit_reached",

package/src/auth-storage.ts

@@ -191,6 +191,7 @@ export type CompletionProbeCredential =
 			projectId?: string;
 			email?: string;
 			enterpriseUrl?: string;
+			apiEndpoint?: string;
 	  };
 
 /**
@@ -638,6 +639,7 @@ export interface OAuthAccess {
 	email?: string;
 	projectId?: string;
 	enterpriseUrl?: string;
+	apiEndpoint?: string;
 }
 
 export interface OAuthAccessFailure {
@@ -646,6 +648,7 @@ export interface OAuthAccessFailure {
 	email?: string;
 	projectId?: string;
 	enterpriseUrl?: string;
+	apiEndpoint?: string;
 	error: string;
 }
 
@@ -1512,17 +1515,6 @@ export class AuthStorage {
 		this.#resetProviderAssignments(provider);
 	}
 
-	async #upsertOAuthCredential(provider: string, credential: OAuthCredential): Promise<void> {
-		const stored = this.#store.upsertAuthCredentialRemote
-			? await this.#store.upsertAuthCredentialRemote(provider, credential)
-			: this.#store.upsertAuthCredentialForProvider(provider, credential);
-		this.#setStoredCredentials(
-			provider,
-			stored.map(record => ({ id: record.id, credential: record.credential })),
-		);
-		this.#resetProviderAssignments(provider);
-	}
-
 	/**
 	 * List stored credential rows, optionally filtered by provider.
 	 */
@@ -1786,7 +1778,10 @@ export class AuthStorage {
 			return;
 		}
 		const newCredential: OAuthCredential = { type: "oauth", ...result };
-		await this.#upsertOAuthCredential(def.storeCredentialsAs ?? provider, newCredential);
+		// Use set() instead of #upsertOAuthCredential to replace ALL existing credentials
+		// (including legacy api_key rows from older versions) with the new OAuth credential.
+		// This ensures getApiKey() doesn't match an old api_key row before the new OAuth row.
+		await this.set(def.storeCredentialsAs ?? provider, newCredential);
 	}
 
 	/**
@@ -1811,6 +1806,7 @@ export class AuthStorage {
 			projectId: credential.projectId,
 			email: credential.email,
 			enterpriseUrl: credential.enterpriseUrl,
+			apiEndpoint: credential.apiEndpoint,
 		};
 	}
 
@@ -1889,6 +1885,7 @@ export class AuthStorage {
 			projectId: credential.projectId,
 			email: credential.email,
 			enterpriseUrl: credential.enterpriseUrl,
+			apiEndpoint: credential.apiEndpoint,
 		};
 	}
 
@@ -1912,6 +1909,7 @@ export class AuthStorage {
 			projectId: credential.projectId,
 			email: credential.email,
 			enterpriseUrl: credential.enterpriseUrl,
+			apiEndpoint: credential.apiEndpoint,
 		};
 	}
 
@@ -1925,6 +1923,7 @@ export class AuthStorage {
 			projectId: refreshed.projectId ?? credential.projectId,
 			email: refreshed.email ?? credential.email,
 			enterpriseUrl: refreshed.enterpriseUrl ?? credential.enterpriseUrl,
+			apiEndpoint: refreshed.apiEndpoint ?? credential.apiEndpoint,
 		};
 	}
 
@@ -1972,6 +1971,7 @@ export class AuthStorage {
 			projectId: next.projectId,
 			email: next.email,
 			enterpriseUrl: next.enterpriseUrl,
+			apiEndpoint: next.apiEndpoint,
 		});
 	}
 
@@ -3392,6 +3392,7 @@ export class AuthStorage {
 				email: result.newCredentials.email ?? selection.credential.email,
 				projectId: result.newCredentials.projectId ?? selection.credential.projectId,
 				enterpriseUrl: result.newCredentials.enterpriseUrl ?? selection.credential.enterpriseUrl,
+				apiEndpoint: result.newCredentials.apiEndpoint ?? selection.credential.apiEndpoint,
 			};
 			this.#replaceCredentialAt(provider, selection.index, updated);
 			if ((checkUsage && !allowBlocked) || requiresProModel) {
@@ -3518,6 +3519,7 @@ export class AuthStorage {
 					return JSON.stringify({
 						token: oauthSelection.credential.access,
 						enterpriseUrl: oauthSelection.credential.enterpriseUrl,
+						apiEndpoint: oauthSelection.credential.apiEndpoint,
 					});
 				}
 				return oauthSelection.credential.access;
@@ -3615,6 +3617,7 @@ export class AuthStorage {
 			email: credential.email,
 			projectId: credential.projectId,
 			enterpriseUrl: credential.enterpriseUrl,
+			apiEndpoint: credential.apiEndpoint,
 		};
 	}
 
@@ -4075,6 +4078,7 @@ export class AuthStorage {
 				email: refreshed.email ?? target.credential.email,
 				projectId: refreshed.projectId ?? target.credential.projectId,
 				enterpriseUrl: refreshed.enterpriseUrl ?? target.credential.enterpriseUrl,
+				apiEndpoint: refreshed.apiEndpoint ?? target.credential.apiEndpoint,
 			};
 			this.#replaceCredentialAt(provider, index, updated);
 			return {